JAVA多线程有哪几种实现方式

JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

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() {  

Systemoutprintln("MyThreadrun()");  

}  

}  

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

[java] view plain copy

MyThread myThread1 = new MyThread();  

MyThread myThread2 = new MyThread();  

myThread1start();  

myThread2start();  

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

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

[java] view plain copy

public class MyThread extends OtherClass implements Runnable {  

public void run() {  

Systemoutprintln("MyThreadrun()");  

}  

}  

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

[java] view plain copy

MyThread myThread = new MyThread();  

Thread thread = new Thread(myThread);  

threadstart();  

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

[java] view plain copy

public void run() {  

if (target != null) {  

targetrun();  

}  

}  

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

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

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

　在传统的同步开发模式下 当我们调用一个函数时 通过这个函数的参数将数据传入 并通过这个函数的返回值来返回最终的计算结果 但在多线程的异步开发模式下 数据的传递和返回和同步开发模式有很大的区别 由于线程的运行和结束是不可预料的 因此 在传递和返回数据时就无法象函数一样通过函数参数和return语句来返回数据 本文就以上原因介绍了几种用于向线程传递数据的方法 在下一篇文章中将介绍从线程中返回数据的方法

　欲先取之 必先予之 一般在使用线程时都需要有一些初始化数据 然后线程利用这些数据进行加工处理 并返回结果 在这个过程中最先要做的就是向线程中传递数据

　 一 通过构造方法传递数据

　在创建线程时 必须要建立一个Thread类的或其子类的实例 因此 我们不难想到在调用start方法之前通过线程类的构造方法将数据传入线程 并将传入的数据使用类变量保存起来 以便线程使用（其实就是在run方法中使用） 下面的代码演示了如何通过构造方法来传递数据

　package mythread;

　public class MyThread extends Thread

　{

　private String name;

　public MyThread (String name)

　{

　this name = name;

　}

　public void run()

　{

　System out println( hello + name);

　}

　public static void main(String[] args)

　{

　Thread thread = new MyThread ( world );

　thread start();

　}

　}

　由于这种方法是在创建线程对象的同时传递数据的 因此 在线程运行之前这些数据就就已经到位了 这样就不会造成数据在线程运行后才传入的现象 如果要传递更复杂的数据 可以使用集合 类等数据结构 使用构造方法来传递数据虽然比较安全 但如果要传递的数据比较多时 就会造成很多不便 由于Java没有默认参数 要想实现类似默认参数的效果 就得使用重载 这样不但使构造方法本身过于复杂 又会使构造方法在数量上大增 因此 要想避免这种情况 就得通过类方法或类变量来传递数据

　 二 通过变量和方法传递数据

　向对象中传入数据一般有两次机会 第一次机会是在建立对象时通过构造方法将数据传入 另外一次机会就是在类中定义一系列的public的方法或变量（也可称之为字段） 然后在建立完对象后 通过对象实例逐个赋值 下面的代码是对MyThread 类的改版 使用了一个setName方法来设置name变量

　package mythread;

　public class MyThread implements Runnable

　{

　private String name;

　public void setName(String name)

　{

　this name = name;

　}

　public void run()

　{

　System out println( hello + name);

　}

　public static void main(String[] args)

　{

　MyThread myThread = new MyThread ();

　myThread setName( world );

　Thread thread = new Thread(myThread);

　thread start();

　}

　}

　 三 通过回调函数传递数据

　上面讨论的两种向线程中传递数据的方法是最常用的 但这两种方法都是main方法中主动将数据传入线程类的 这对于线程来说 是被动接收这些数据的 然而 在有些应用中需要在线程运行的过程中动态地获取数据 如在下面代码的run方法中产生了 个随机数 然后通过Work类的process方法求这三个随机数的和 并通过Data类的value将结果返回 从这个例子可以看出 在返回value之前 必须要得到三个随机数 也就是说 这个value是无法事先就传入线程类的

　package mythread;

　class Data

　{

　public int value = ;

　}

　class Work

　{

　public void process(Data data Integer numbers)

　{

　for (int n : numbers)

　{

　data value += n;

　}

　}

　}

　public class MyThread extends Thread

　{

　private Work work;

　public MyThread (Work work)

　{

　this work = work;

　}

　public void run()

　{

　java util Random random = new java util Random();

　Data data = new Data();

　int n = random nextInt( );

　int n = random nextInt( );

　int n = random nextInt( );

　work process(data n n n );   // 使用回调函数

　System out println(String valueOf(n ) + + + String valueOf(n ) + +

　+ String valueOf(n ) + = + data value);

　}

　public static void main(String[] args)

　{

　Thread thread = new MyThread (new Work());

　thread start();

　}

　}

lishixinzhi/Article/program/Java/hx/201311/26623

楼主，你这个程序很有意思，我做了稍微修改。

你这程序的需要解决的问题是，如何保证线程在修改完b的值，即（b=2000）时，才让主线程输出b的值。我是通过在main函数中用while循环的方式来达到这样的目的，也就是轮询方法啦。经过运行，效果达到。

public class TT implements Runnable {

int b = 100;

boolean isFinish = false;//该变量用于标识m1(),m2()方法是否都运行完毕

public synchronized void m1() throws Exception{

//Threadsleep(2000);

b = 1000;

Threadsleep(5000);

Systemoutprintln("b = " + b);

}

public synchronized void m2() throws Exception {

Threadsleep(2500);

b = 2000;

}

public void run() {

try {

m1();

m2();//这样m2才是线程调用

isFinish = true;//如果m1,m2执行完毕，则isFinish为true这句是关键

} catch(Exception e) {

eprintStackTrace();

}

}

public static void main(String[] args) throws Exception {

TT tt = new TT();

Thread t = new Thread(tt);

tstart();

//ttm2();这样调用不是线程调用。如果是线程调用的话，应该把m2方法放在run（）内

while(!ttisFinish);//这轮询,保证t线程执行完毕（即m1和m2的方法都执行了），才让主线程输出b的值。

Systemoutprintln(ttb);

}

}

public class ThreadTest {

public static void main(String[] args) {

new Thread("自定义线程:") {

public void run() {

int a=new Object() {//临时借用匿名类!

public int show() {

return 1+2;

}

}show();

Systemoutprintln(ThreadcurrentThread()getName()+"a="+a);

}

}start();

Systemoutprintln("这是主线程:"+ThreadcurrentThread()getName());

}

}