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

Java多线程的创建及启动

Java中线程的创建常见有如三种基本形式

1继承Thread类，重写该类的run()方法。

复制代码

1 class MyThread extends Thread {

2  

3     private int i = 0;

4

5     @Override

6     public void run() {

7         for (i = 0; i < 100; i++) {

8             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

9         }

10     }

11 }

复制代码

复制代码

1 public class ThreadTest {

2

3     public static void main(String[] args) {

4         for (int i = 0; i < 100; i++) {

5             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

6             if (i == 30) {

7                 Thread myThread1 = new MyThread();     // 创建一个新的线程  myThread1  此线程进入新建状态

8                 Thread myThread2 = new MyThread();     // 创建一个新的线程 myThread2 此线程进入新建状态

9                 myThread1start();                     // 调用start()方法使得线程进入就绪状态

10                 myThread2start();                     // 调用start()方法使得线程进入就绪状态

11             }

12         }

13     }

14 }

复制代码

如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

2实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

复制代码

1 class MyRunnable implements Runnable {

2     private int i = 0;

3

4     @Override

5     public void run() {

6         for (i = 0; i < 100; i++) {

7             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

8         }

9     }

10 }

复制代码

复制代码

1 public class ThreadTest {

2

3     public static void main(String[] args) {

4         for (int i = 0; i < 100; i++) {

5             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

6             if (i == 30) {

7                 Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象

8                 Thread thread1 = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程

9                 Thread thread2 = new Thread(myRunnable);

10                 thread1start(); // 调用start()方法使得线程进入就绪状态

11                 thread2start();

12             }

13         }

14     }

15 }

复制代码

相信以上两种创建新线程的方式大家都很熟悉了，那么Thread和Runnable之间到底是什么关系呢？我们首先来看一下下面这个例子。

复制代码

1 public class ThreadTest {

2

3     public static void main(String[] args) {

4         for (int i = 0; i < 100; i++) {

5             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

6             if (i == 30) {

7                 Runnable myRunnable = new MyRunnable();

8                 Thread thread = new MyThread(myRunnable);

9                 threadstart();

10             }

11         }

12     }

13 }

14

15 class MyRunnable implements Runnable {

16     private int i = 0;

17

18     @Override

19     public void run() {

20         Systemoutprintln("in MyRunnable run");

21         for (i = 0; i < 100; i++) {

22             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

23         }

24     }

25 }

26

27 class MyThread extends Thread {

28

29     private int i = 0;

30  

31     public MyThread(Runnable runnable){

32         super(runnable);

33     }

34

35     @Override

36     public void run() {

37         Systemoutprintln("in MyThread run");

38         for (i = 0; i < 100; i++) {

39             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

40         }

41     }

42 }

复制代码

同样的，与实现Runnable接口创建线程方式相似，不同的地方在于

1 Thread thread = new MyThread(myRunnable);

那么这种方式可以顺利创建出一个新的线程么？答案是肯定的。至于此时的线程执行体到底是MyRunnable接口中的run()方法还是MyThread类中的run()方法呢？通过输出我们知道线程执行体是MyThread类中的run()方法。其实原因很简单，因为Thread类本身也是实现了Runnable接口，而run()方法最先是在Runnable接口中定义的方法。

1 public interface Runnable {

2  

3     public abstract void run();

4  

5 }

我们看一下Thread类中对Runnable接口中run()方法的实现：

复制代码

@Override

public void run() {

if (target != null) {

targetrun();

}

}

复制代码

也就是说，当执行到Thread类中的run()方法时，会首先判断target是否存在，存在则执行target中的run()方法，也就是实现了Runnable接口并重写了run()方法的类中的run()方法。但是上述给到的列子中，由于多态的存在，根本就没有执行到Thread类中的run()方法，而是直接先执行了运行时类型即MyThread类中的run()方法。

3使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

看着好像有点复杂，直接来看一个例子就清晰了。

复制代码

1 public class ThreadTest {

2

3     public static void main(String[] args) {

4

5         Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象

6         FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

7

8         for (int i = 0; i < 100; i++) {

9             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

10             if (i == 30) {

11                 Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程

12                 threadstart();                      //线程进入到就绪状态

13             }

14         }

15

16         Systemoutprintln("主线程for循环执行完毕");

17      

18         try {

19             int sum = ftget();            //取得新创建的新线程中的call()方法返回的结果

20             Systemoutprintln("sum = " + sum);

21         } catch (InterruptedException e) {

22             eprintStackTrace();

23         } catch (ExecutionException e) {

24             eprintStackTrace();

25         }

26

27     }

28 }

29

30

31 class MyCallable implements Callable<Integer> {

32     private int i = 0;

33

34     // 与run()方法不同的是，call()方法具有返回值

35     @Override

36     public Integer call() {

37         int sum = 0;

38         for (; i < 100; i++) {

39             Systemoutprintln(ThreadcurrentThread()getName() + " " + i);

40             sum += i;

41         }

42         return sum;

43     }

44

45 }

复制代码

首先，我们发现，在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。那么看下FutureTask类的定义：

1 public class FutureTask<V> implements RunnableFuture<V> {

2  

3     //

4  

5 }

1 public interface RunnableFuture<V> extends Runnable, Future<V> {

2  

3     void run();

4  

5 }

于是，我们发现FutureTask类实际上是同时实现了Runnable和Future接口，由此才使得其具有Future和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，使得其可以取得新创建线程中的call()方法的返回值。

执行下此程序，我们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕”则很可能是在子线程循环中间输出。由CPU的线程调度机制，我们知道，“主线程for循环执行完毕”的输出时机是没有任何问题的，那么为什么sum =4950会永远最后输出呢？

原因在于通过ftget()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ftget()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。

上述主要讲解了三种常见的线程创建方式，对于线程的启动而言，都是调用线程对象的start()方法，需要特别注意的是：不能对同一线程对象两次调用start()方法。

你好，本题已解答,如果满意

请点右下角“采纳答案”。

1、设计一个线程，产生三个线程对象，设置三个线程的休眠时间，10s，20s，30s。主要采用Thread类，Runable接口。

2、thread类是javalang包中定义的，一个类只要继承Thread类，此类就是多线程 *** 作类使用Threa类实现。

3、测试运行结果。

4、使用runnable接口实现，类中没有线程名称字段，所以建立一个name属性保存线程名称。

5、使用runnable接口，new Thread()start() 执行。

最早知道ThreadLocal是在Looper的源码里，用一个ThreadLocal保存了当前的looper对象。

当时就查了下ThreadLocal，发现是保存线程私有对象的容器，以为就是一个类似hashmap，用线程做key，存value。最近看了下并不是如此，实际上是以ThreadLocal自身为key来存储对象的。于是来学习下ThreadLocal源码是如何做到保存线程私有对象的。

ThreadLocal、ThreadLocalMap、Thread之间的关系和我们下意识中想的不太一样，不过一步步看下去之后就能明白为啥ThreadLocal能保存线程私有对象了。

这个是Thread源码，每一个Thread都有一个ThreadLocalMap对象，而ThreadLocalMap是ThreadLocal的内部类，是实际存储对象的容器。

基本关系知道了，最后再来看看ThreadLocal的方法：

那么现在基本完全清楚ThreadLocal与Thread还有ThreadLocalMap之间的关系了。

每个Thread都有一个成员变量ThreadLocalMap。这个ThreadLocalMap对象不是public，所以外部调用不了，可以看做是线程私有对象。

ThreadLocalMap存了一个table，table里保存了一些entry，每个entry对应一个key和value，而这个key就是ThreadLocal对象。

因此一个ThreadLocal只能存一个value，但是可以通过new多个ThreadLocal来保存多个线程私有对象。

在上面的源码中我们看到Entry里持有的ThreadLocal对象是弱引用持有，因此ThreadLocal不会因为线程持有而泄露，比如我们Android的主线程，正常使用过程中是不会挂掉的。

但是Enrty的value的是强引用的，因此ThreadLocal中的value还是会因为线程持有而无法回收。如果继续看源码的话，会发现在ThreadLocalMap的resize和expungeStaleEntry方法里会检查key为空的value值为空帮助GC。

因此为了避免value内存泄露，我们需要在ThreadLocal不需要的时候主动remove掉。

ThreadLocal通过自身的threadLocalHashCode来碰撞得到自己在ThreadLocalMap的table里的索引i。因此这个threadLocalHashCode就十分重要了。

这里需要保证threadLocalHashCode是唯一的，否则两个线程同时创建ThreadLocal得到相同的hashcode，那就破坏了ThreadLocalMap的线程私有特性了。

这里生成threadLocalHashCode是通过一个静态对象nextHashCode不断增加来获得的。那怎么保证多个进程并发实例化ThreadLocal对象，不会生成相同的hashcode呢？

答案是AtomicInteger，通过这个类来保证变量自增 *** 作在多线程 *** 作时候的原子性。

我们知道Synchronized也可以保证原子性，但相比于它，AtomicInteger类是通过非阻塞方法来实现原子性的，需要的性能开销更小。

这种非阻塞实现原子性的方法和处理器的CAS指令有关，感兴趣的小伙伴自行研究吧~

获取线程名字这件事情本质上和Runnable是没有关系的。一个Runnable可以给多个线程去运行，所以如果在这个概念上你有误解的话，希望重新考虑一下。

另外，在任何时候，你都可以用ThreadcurrentThread()getName()来获取当前线程的名字

既然是web项目，你可以先试着把你要的对象放到session中，毕竟session比ruquest的生命周期更长，可以先看看放在session中能不能拿到。如果值是从页面上来的，requestgetparameter(“参数名”) ,requestgetSession()getAttribute("参数名")，你先用seesion试试，看看能不能解决

在传统的同步开发模式下 当我们调用一个函数时 通过这个函数的参数将数据传入 并通过这个函数的返回值来返回最终的计算结果 但在多线程的异步开发模式下 数据的传递和返回和同步开发模式有很大的区别 由于线程的运行和结束是不可预料的 因此 在传递和返回数据时就无法象函数一样通过函数参数和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

以上就是关于在Java 中多线程的实现方法有哪些，如何使用全部的内容，包括:在Java 中多线程的实现方法有哪些，如何使用、如何创建和启动一个线程、ThreadLocal是如何实现保存线程私有对象的等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！