java中实现多线程代码 java实现多线程方法

java 多线程有几种实现方法

1、继承Thread类实现多线程

创新互联服务项目包括汉南网站建设、汉南网站制作、汉南网页制作以及汉南网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，汉南网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到汉南省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

[java] view plain copy

public class MyThread extends Thread {

public void run() {

System.out.println("MyThread.run()");

}

}

在合适的地方启动线程如下：

[java] view plain copy

MyThread myThread1 = new MyThread();

MyThread myThread2 = new MyThread();

myThread1.start();

myThread2.start();

2、实现Runnable接口方式实现多线程

如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：

[java] view plain copy

public class MyThread extends OtherClass implements Runnable {

public void run() {

System.out.println("MyThread.run()");

}

}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

[java] view plain copy

MyThread myThread = new MyThread();

Thread thread = new Thread(myThread);

thread.start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

[java] view plain copy

public void run() {

if (target != null) {

target.run();

}

}

3、使用ExecutorService、Callable、Future实现有返回结果的多线程

ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问 ，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。

可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。

Java多线程程序设计初步入门

在Java语言产生前 传统的程序设计语言的程序同一时刻只能单任务操作 效率非常低 例如程序往往在接收数据输入时发生阻塞 只有等到程序获得数据后才能继续运行 随着Internet的迅猛发展 这种状况越来越不能让人们忍受 如果网络接收数据阻塞 后台程序就处于等待状态而不继续任何操作 而这种阻塞是经常会碰到的 此时CPU资源被白白的闲置起来 如果在后台程序中能够同时处理多个任务 该多好啊！应Internet技术而生的Java语言解决了这个问题 多线程程序是Java语言的一个很重要的特点 在一个Java程序中 我们可以同时并行运行多个相对独立的线程 例如 我们如果创建一个线程来进行数据输入输出 而创建另一个线程在后台进行其它的数据处理 如果输入输出线程在接收数据时阻塞 而处理数据的线程仍然在运行 多线程程序设计大大提高了程序执行效率和处理能力

线程的创建

我们知道Java是面向对象的程序语言 用Java进行程序设计就是设计和使用类 Java为我们提供了线程类Thread来创建线程 创建线程与创建普通的类的对象的操作是一样的 而线程就是Thread类或其子类的实例对象 下面是一个创建启动一个线程的语句

Thread thread =new Thread(); file://声明一个对象实例 即创建一个线程

Thread run(); file://用Thread类中的run()方法启动线程

从这个例子 我们可以通过Thread（）构造方法创建一个线程 并启动该线程 事实上 启动线程 也就是启动线程的run（）方法 而Thread类中的run（）方法没有任何操作语句 所以这个线程没有任何操作 要使线程实现预定功能 必须定义自己的run（）方法 Java中通常有两种方式定义run（）方法

通过定义一个Thread类的子类 在该子类中重写run（）方法 Thread子类的实例对象就是一个线程 显然 该线程有我们自己设计的线程体run（）方法 启动线程就启动了子类中重写的run（）方法

通过Runnable接口 在该接口中定义run（）方法的接口 所谓接口跟类非常类似 主要用来实现特殊功能 如复杂关系的多重继承功能 在此 我们定义一个实现Runnable（） 接口的类 在该类中定义自己的run（）方法 然后以该类的实例对象为参数调用Thread类的构造方法来创建一个线程

线程被实际创建后处于待命状态 激活（启动）线程就是启动线程的run（）方法 这是通过调用线程的start（）方法来实现的

下面一个例子实践了如何通过上述两种方法创建线程并启动它们

// 通过Thread类的子类创建的线程 　 class thread extends Thread { file://自定义线程的run()方法 　 public void run() { 　 System out println( Thread is running… ); } 　 } 　 file://通过Runnable接口创建的另外一个线程 class thread implements Runnable 　 { file://自定义线程的run()方法 public void run() { 　 System out println( Thread is running… ); } 　 } 　 file://程序的主类 　 class Multi_Thread file://声明主类 { 　 plubic static void mail(String args[]) file://声明主方法 { 　 thread threadone=new thread (); file://用Thread类的子类创建线程 　 Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程 　 threadone start(); threado start(); 方法启动线程 } 　 }

运行该程序就可以看出 线程threadone和threado交替占用CPU 处于并行运行状态 可以看出 启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类) 调用start()方法启动线程的run()方法不同于一般的调用方法 调用一般方法时 必须等到一般方法执行完毕才能够返回start()方法 而启动线程的run()方法后 start()告诉系统该线程准备就绪可以启动run()方法后 就返回start()方法执行调用start()方法语句下面的语句 这时run()方法可能还在运行 这样 线程的启动和运行并行进行 实现了多任务操作

线程的优先级

对于多线程程序 每个线程的重要程度是不尽相同 如多个线程在等待获得CPU时间时 往往我们需要优先级高的线程优先抢占到CPU时间得以执行 又如多个线程交替执行时 优先级决定了级别高的线程得到CPU的次数多一些且时间多长一些 这样 高优先级的线程处理的任务效率就高一些

Java中线程的优先级从低到高以整数 ~ 表示 共分为 级 设置优先级是通过调用线程对象的setPriority()方法 如上例中 设置优先级的语句为

thread threadone=new thread (); file://用Thread类的子类创建线程

Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程

threadone setPriority( ); file://设置threadone的优先级

threado setPriority( ); file://设置threado的优先级

threadone start(); threado start(); 方法启动线程

这样 线程threadone将会优先于线程threado执行 并将占有更多的CPU时间 该例中 优先级设置放在线程启动前 也可以在启动后进行设置 以满足不同的优先级需求

线程的（同步）控制

一个Java程序的多线程之间可以共享数据 当线程以异步方式访问共享数据时 有时候是不安全的或者不和逻辑的 比如 同一时刻一个线程在读取数据 另外一个线程在处理数据 当处理数据的线程没有等到读取数据的线程读取完毕就去处理数据 必然得到错误的处理结果 这和我们前面提到的读取数据和处理数据并行多任务并不矛盾 这儿指的是处理数据的线程不能处理当前还没有读取结束的数据 但是可以处理其它的数据

如果我们采用多线程同步控制机制 等到第一个线程读取完数据 第二个线程才能处理该数据 就会避免错误 可见 线程同步是多线程编程的一个相当重要的技术

在讲线程的同步控制前我们需要交代如下概念

用Java关键字synchonized同步对共享数据操作的方法

在一个对象中 用synchonized声明的方法为同步方法 Java中有一个同步模型 监视器 负责管理线程对对象中的同步方法的访问 它的原理是 赋予该对象唯一一把 钥匙 当多个线程进入对象 只有取得该对象钥匙的线程才可以访问同步方法 其它线程在该对象中等待 直到该线程用wait（）方法放弃这把钥匙 其它等待的线程抢占该钥匙 抢占到钥匙的线程后才可得以执行 而没有取得钥匙的线程仍被阻塞在该对象中等待

file://声明同步的一种方式 将方法声明同步

class store　 {public synchonized void store_in(){… }public synchonized void store_out(){　 … }}

利用wait（） notify（）及notifyAll（）方法发送消息实现线程间的相互联系

Java程序中多个线程通过消息来实现互动联系的 这几种方法实现了线程间的消息发送 例如定义一个对象的synchonized 方法 同一时刻只能够有一个线程访问该对象中的同步方法 其它线程被阻塞 通常可以用notify（）或notifyAll（）方法唤醒其它一个或所有线程 而使用wait（）方法来使该线程处于阻塞状态 等待其它的线程用notify（）唤醒

一个实际的例子就是生产和销售 生产单元将产品生产出来放在仓库中 销售单元则从仓库中提走产品 在这个过程中 销售单元必须在仓库中有产品时才能提货 如果仓库中没有产品 则销售单元必须等待

程序中 假如我们定义一个仓库类store 该类的实例对象就相当于仓库 在store类中定义两个成员方法 store_in（） 用来模拟产品制造者往仓库中添加产品 strore_out（）方法则用来模拟销售者从仓库中取走产品 然后定义两个线程类 customer类 其中的run（）方法通过调用仓库类中的store_out（）从仓库中取走产品 模拟销售者 另外一个线程类producer中的run（）方法通过调用仓库类中的store_in（）方法向仓库添加产品 模拟产品制造者 在主类中创建并启动线程 实现向仓库中添加产品或取走产品

如果仓库类中的store_in（） 和store_out（）方法不声明同步 这就是个一般的多线程 我们知道 一个程序中的多线程是交替执行的 运行也是无序的 这样 就可能存在这样的问题

仓库中没有产品了 销售者还在不断光顾 而且还不停的在 取 产品 这在现实中是不可思义的 在程序中就表现为负值 如果将仓库类中的stroe_in（）和store_out（）方法声明同步 如上例所示 就控制了同一时刻只能有一个线程访问仓库对象中的同步方法 即一个生产类线程访问被声明为同步的store_in（）方法时 其它线程将不能够访问对象中的store_out（）同步方法 当然也不能访问store_in（）方法 必须等到该线程调用wait（）方法放弃钥匙 其它线程才有机会访问同步方法

lishixinzhi/Article/program/Java/gj/201311/27301

编写一个多线程的java 程序

public class RunThread implements Runnable{

String name;

Thread runner;

static boolean bool=true;

public RunThread(String threadName) {

name=threadName;

}

public void onStart()

{

runner = new Thread(this);

runner.setName(name);

runner.start();

}

public void run() {

String name=Thread.currentThread().getName();

System.out.println(name + " 线程运行开始!");

int index=0;

if(name.equals("小写字母"))

index='a';

else if(name.equals("大写字母"))

index='A';

while(!bool);

bool=false;

for(int i=index;i26+index;i++)

System.out.print((char)i+" ");

System.out.println();

bool=true;

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(name + " 线程运行结束!");

}

public static void main(String[] args) {

RunThread a=new RunThread("小写字母");

RunThread b=new RunThread("大写字母");

a.onStart();

b.onStart();

//System.out.println(" 线程运行开始!");

}

在Java 中多线程的实现方法有哪些，如何使用～～～～～～～～～～～～～～～～～～急

1、 认识Thread和Runnable

Java中实现多线程有两种途径：继承Thread类或者实现Runnable接口。Runnable是接口，建议用接口的方式生成线程，因为接口可以实现多继承，况且Runnable只有一个run方法，很适合继承。在使用Thread的时候只需继承Thread，并且new一个实例出来，调用start()方法即可以启动一个线程。

Thread Test = new Thread();

Test.start();

在使用Runnable的时候需要先new一个实现Runnable的实例，之后启动Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

总结：Thread和Runnable是实现java多线程的2种方式，runable是接口，thread是类，建议使用runable实现java多线程，不管如何，最终都需要通过thread.start()来使线程处于可运行状态。

2、 认识Thread的start和run

1） start：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到spu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

3、 线程状态说明

线程状态从大的方面来说，可归结为：初始状态、可运行状态、不可运行状态和消亡状态，具体可细分为上图所示7个状态，说明如下：

1） 线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了thread实例后，线程就进入了初始状态；

2） 当该对象调用了start()方法，就进入可运行状态；

3） 进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；

4） 进入运行状态后case就比较多，大致有如下情形：

·run()方法或main()方法结束后，线程就进入终止状态；

·当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片；

·当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被锁牢(synchroniza,lock)，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片；

·当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。

·当线程调用stop方法，即可使线程进入消亡状态，但是由于stop方法是不安全的，不鼓励使用，大家可以通过run方法里的条件变通实现线程的stop。