Java多线程学习（总结很详细！！！）

此文只能说是java多线程的一个入门，其实Java里头线程完全可以写一本书了，但是如果最基本的你都学掌握好，又怎么能更上一个台阶呢？

       本文主要讲java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的线程函数用法、概述等。首先让我们来了解下在操作系统中进程和线程的区别：

　　进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位）

　　线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

　　线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。

　　多进程是指操作系统能同时运行多个任务（程序）。

　　多线程是指在同一程序中有多个顺序流在执行。

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口.(其实准确来讲，应该有三种，还有一种是实现Callable接口，并与Future、线程池结合使用，此文这里不讲这个。

一、扩展java.lang.Thread类

这里继承Thread类的方法是比较常用的一种，如果说你只是想起一条线程。没有什么其它特殊的要求，那么可以使用Thread.（笔者推荐使用Runable，后头会说明为什么）。下面来看一个简单的实例

 1 package com.multithread.learning;  
 2 /** 
 3  *@functon 多线程学习 
 4  */  
 5 class Thread1 extends Thread{  
 6     private String name;  
 7     public Thread1(String name) {  
 8        this.name=name;  
 9     }  
10     public void run() {  
11         for (int i = 0; i < 5; i++) {  
12             System.out.println(name + "运行  :  " + i);  
13             try {  
14                 sleep((int) Math.random() * 10);  
15             } catch (InterruptedException e) {  
16                 e.printStackTrace();  
17             }  
18         }  
19          
20     }  
21 }  
22 public class Main {  
23   
24     public static void main(String[] args) {  
25         Thread1 mTh1=new Thread1("A");  
26         Thread1 mTh2=new Thread1("B");  
27         mTh1.start();  
28         mTh2.start();  
29   
30     }  
31   
32 }  

输出：

A运行  :  0
B运行  :  0
A运行  :  1
A运行  :  2
A运行  :  3
A运行  :  4
B运行  :  1
B运行  :  2
B运行  :  3
B运行  :  4

再运行一下：

A运行  :  0
B运行  :  0
B运行  :  1
B运行  :  2
B运行  :  3
B运行  :  4
A运行  :  1
A运行  :  2
A运行  :  3
A运行  :  4

但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

1 Thread1 mTh1=new Thread1("A");  
2 Thread1 mTh2=mTh1;  
3 mTh1.start();  
4 mTh2.start();  

输出：

Exception in thread "main" java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Unknown Source)
    at com.multithread.learning.Main.main(Main.java:31)
A运行  :  0
A运行  :  1
A运行  :  2
A运行  :  3
A运行  :  4

二、实现java.lang.Runnable接口

采用Runnable也是非常常见的一种，我们只需要重写run方法即可。下面也来看个实例。 

 1 /** 
 2  *@functon 多线程学习 
 3  */  
 4 package com.multithread.runnable;  
 5 class Thread2 implements Runnable{  
 6     private String name;  
 7   
 8     public Thread2(String name) {  
 9         this.name=name;  
10     }  
11   
12     @Override  
13     public void run() {  
14           for (int i = 0; i < 5; i++) {  
15                 System.out.println(name + "运行  :  " + i);  
16                 try {  
17                     Thread.sleep((int) Math.random() * 10);  
18                 } catch (InterruptedException e) {  
19                     e.printStackTrace();  
20                 }  
21             }  
22           
23     }  
24       
25 }  
26 public class Main {  
27   
28     public static void main(String[] args) {  
29         new Thread(new Thread2("C")).start();  
30         new Thread(new Thread2("D")).start();  
31     }  
32   
33 }  

输出：

C运行  :  0
D运行  :  0
D运行  :  1
C运行  :  1
D运行  :  2
C运行  :  2
D运行  :  3
C运行  :  3
D运行  :  4
C运行  :  4

总结：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

四、线程状态转换

五、线程调度

线程的调度

1 Thread t = new AThread(); t.start(); t.join();  

 1 /** 
 2  *@functon 多线程学习,join 
 3  */  
 4 package com.multithread.join;  
 5 class Thread1 extends Thread{  
 6     private String name;  
 7     public Thread1(String name) {  
 8         super(name);  
 9        this.name=name;  
10     }  
11     public void run() {  
12         System.out.println(Thread.currentThread().getName() + " 线程运行开始!");  
13         for (int i = 0; i < 5; i++) {  
14             System.out.println("子线程"+name + "运行 : " + i);  
15             try {  
16                 sleep((int) Math.random() * 10);  
17             } catch (InterruptedException e) {  
18                 e.printStackTrace();  
19             }  
20         }  
21         System.out.println(Thread.currentThread().getName() + " 线程运行结束!");  
22     }  
23 }  
24   
25 public class Main {  
26   
27     public static void main(String[] args) {  
28         System.out.println(Thread.currentThread().getName()+"主线程运行开始!");  
29         Thread1 mTh1=new Thread1("A");  
30         Thread1 mTh2=new Thread1("B");  
31         mTh1.start();  
32         mTh2.start();  
33         System.out.println(Thread.currentThread().getName()+ "主线程运行结束!");  
34   
35     }  
36   
37 }  

 1 public class Main {  
 2   
 3     public static void main(String[] args) {  
 4         System.out.println(Thread.currentThread().getName()+"主线程运行开始!");  
 5         Thread1 mTh1=new Thread1("A");  
 6         Thread1 mTh2=new Thread1("B");  
 7         mTh1.start();  
 8         mTh2.start();  
 9         try {  
10             mTh1.join();  
11         } catch (InterruptedException e) {  
12             e.printStackTrace();  
13         }  
14         try {  
15             mTh2.join();  
16         } catch (InterruptedException e) {  
17             e.printStackTrace();  
18         }  
19         System.out.println(Thread.currentThread().getName()+ "主线程运行结束!");  
20   
21     }  
22   
23 }  

 1 /** 
 2  *@functon 多线程学习 yield 
 3  */  
 4 package com.multithread.yield;  
 5 class ThreadYield extends Thread{  
 6     public ThreadYield(String name) {  
 7         super(name);  
 8     }  
 9    
10     @Override  
11     public void run() {  
12         for (int i = 1; i <= 50; i++) {  
13             System.out.println("" + this.getName() + "-----" + i);  
14             // 当i为30时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）  
15             if (i ==30) {  
16                 this.yield();  
17             }  
18         }  
19       
20 }  
21 }  
22   
23 public class Main {  
24   
25     public static void main(String[] args) {  
26           
27         ThreadYield yt1 = new ThreadYield("张三");  
28         ThreadYield yt2 = new ThreadYield("李四");  
29         yt1.start();  
30         yt2.start();  
31     }  
32   
33 }  

Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

 1 /** 
 2  * wait用法 
 3  * @author DreamSea   
 4  */  
 5 package com.multithread.wait;  
 6 public class MyThreadPrinter2 implements Runnable {     
 7         
 8     private String name;     
 9     private Object prev;     
10     private Object self;     
11     
12     private MyThreadPrinter2(String name, Object prev, Object self) {     
13         this.name = name;     
14         this.prev = prev;     
15         this.self = self;     
16     }     
17     
18     @Override    
19     public void run() {     
20         int count = 10;     
21         while (count > 0) {     
22             synchronized (prev) {     
23                 synchronized (self) {     
24                     System.out.print(name);     
25                     count--;    
26                       
27                     self.notify();     
28                 }     
29                 try {     
30                     prev.wait();     
31                 } catch (InterruptedException e) {     
32                     e.printStackTrace();     
33                 }     
34             }     
35     
36         }     
37     }     
38     
39     public static void main(String[] args) throws Exception {     
40         Object a = new Object();     
41         Object b = new Object();     
42         Object c = new Object();     
43         MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);     
44         MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);     
45         MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);     
46              
47              
48         new Thread(pa).start();  
49         Thread.sleep(100);  //确保按顺序A、B、C执行  
50         new Thread(pb).start();  
51         Thread.sleep(100);    
52         new Thread(pc).start();     
53         Thread.sleep(100);    
54         }     
55 }    

线程类的一些常用方法： 

　　sleep(): 强迫一个线程睡眠Ｎ毫秒。 
　　isAlive(): 判断一个线程是否存活。 
　　join(): 等待线程终止。 
　　activeCount(): 程序中活跃的线程数。 
　　enumerate(): 枚举程序中的线程。 
    currentThread(): 得到当前线程。 
　　isDaemon(): 一个线程是否为守护线程。 
　　setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束) 
　　setName(): 为线程设置一个名称。 
　　wait(): 强迫一个线程等待。 
　　notify(): 通知一个线程继续运行。 
　　setPriority(): 设置一个线程的优先级。

八、线程同步

1、synchronized关键字的作用域有二种： 
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。 

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象； 

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法； 

Java对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对synchronized关键字的作用进行深入了解才可定论。

总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。

在进一步阐述之前，我们需要明确几点：

A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

B．每个对象只有一个锁（lock）与之相关联。

C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

接着来讨论synchronized用到不同地方对代码产生的影响：

假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。

1．  把synchronized当作函数修饰符时，示例代码如下：

Public synchronized void methodAAA()

{

//….

}

这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。

上边的示例代码等同于如下代码：

public void methodAAA()

{

synchronized (this)      //  (1)

{

       //…..

}

}

 (1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（

2．同步块，示例代码如下：

            public void method3(SomeObject so)

              {

                     synchronized(so)

{

       //…..

}

}

这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

class Foo implements Runnable

{

       private byte[] lock = new byte[0];  // 特殊的instance变量

    Public void methodA()

{

       synchronized(lock) { //… }

}

//…..

}

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

3．将synchronized作用于static 函数，示例代码如下：

      Class Foo

{

public synchronized static void methodAAA()   // 同步的static 函数

{

//….

}

public void methodBBB()

{

       synchronized(Foo.class)   //  class literal(类名称字面常量)

}

       }

   代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。

记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不一样，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。

可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。

九、线程数据传递

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

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

 1 package mythread;   
 2 public class MyThread1 extends Thread   
 3 {   
 4 private String name;   
 5 public MyThread1(String name)   
 6 {   
 7 this.name = name;   
 8 }   
 9 public void run()   
10 {   
11 System.out.println("hello " + name);   
12 }   
13 public static void main(String[] args)   
14 {   
15 Thread thread = new MyThread1("world");   
16 thread.start();   
17 }   
18 }   

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

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

 1 package mythread;   
 2 public class MyThread2 implements Runnable   
 3 {   
 4 private String name;   
 5 public void setName(String name)   
 6 {   
 7 this.name = name;   
 8 }   
 9 public void run()   
10 {   
11 System.out.println("hello " + name);   
12 }   
13 public static void main(String[] args)   
14 {   
15 MyThread2 myThread = new MyThread2();   
16 myThread.setName("world");   
17 Thread thread = new Thread(myThread);   
18 thread.start();   
19 }   
20 }   

9.3、通过回调函数传递数据 

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

 1 package mythread;   
 2 class Data   
 3 {   
 4 public int value = 0;   
 5 }   
 6 class Work   
 7 {   
 8 public void process(Data data, Integer numbers)   
 9 {   
10 for (int n : numbers)   
11 {   
12 data.value += n;   
13 }   
14 }   
15 }   
16 public class MyThread3 extends Thread   
17 {   
18 private Work work;   
19 public MyThread3(Work work)   
20 {   
21 this.work = work;   
22 }   
23 public void run()   
24 {   
25 java.util.Random random = new java.util.Random();   
26 Data data = new Data();   
27 int n1 = random.nextInt(1000);   
28 int n2 = random.nextInt(2000);   
29 int n3 = random.nextInt(3000);   
30 work.process(data, n1, n2, n3); // 使用回调函数   
31 System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+"   
32 + String.valueOf(n3) + "=" + data.value);   
33 }   
34 public static void main(String[] args)   
35 {   
36 Thread thread = new MyThread3(new Work());   
37 thread.start();   
38 }   
39 }   

  好了，Java多线程的基础知识就讲到这里了，有兴趣研究多线程的推荐直接看java的源码，你将会得到很大的提升！