Java 多线程同步

1.线程

创建一个线程有两个方法：继承java.lang.Thread类或实现java.lang.Runnable接口。

main() 函数也是一个线程。

 

1.1继承Thread

Thread 类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建一个线程，程序员必须创建一个从 Thread 类导出的新类。程序员必须覆盖 Thread 的 run() 函数来完成有用的工作。用户并不直接调用此函数；而是必须调用 Thread 的 start() 函数，该函数再调用 run()。下面的代码说明了它的用法：

[java] view plain copy

1. import java.util.*;  
2. class TimePrinter extends Thread {  
3.     int pauseTime;  
4.     String name;  
5.     public TimePrinter(int x, String n) {  
6.         pauseTime = x;  
7.         name = n;  
8.     }  
9.     public void run() {  
10.         while(true) {  
11.             try {  
12.                 System.out.println(name + ":" + new   
13.                     Date(System.currentTimeMillis()));  
14.                 Thread.sleep(pauseTime);  
15.             } catch(Exception e) {  
16.                 System.out.println(e);  
17.             }  
18.         }  
19.     }  
20.     static public void main(String args[]) {  
21.         TimePrinter tp1 = new TimePrinter(1000, "Fast Guy");  
22.         tp1.start();  
23.         TimePrinter tp2 = new TimePrinter(3000, "Slow Guy");  
24.         tp2.start();  
25.     }   
26. }  

 

1.2实现Runnable

此接口只有一个函数，run()，此函数必须由实现了此接口的类实现。但是，就运行这个类而论，其语义与前一个示例稍有不同。我们可以用 runnable 接口改写前一个示例。

 

 

[java] view plain copy

1. import java.util.*;  
2. class TimePrinter   
3.         implements Runnable {  
4.     int pauseTime;  
5.     String name;  
6.     public TimePrinter(int x, String n) {  
7.         pauseTime = x;  
8.         name = n;  
9.     }  
10.     public void run() {  
11.         while(true) {  
12.             try {  
13.                 System.out.println(name + ":" + new   
14.                     Date(System.currentTimeMillis()));  
15.                 Thread.sleep(pauseTime);  
16.             } catch(Exception e) {  
17.                 System.out.println(e);  
18.             }  
19.         }  
20.     }  
21.     static public void main(String args[]) {  
22.         Thread t1 = new Thread (new TimePrinter(1000, "Fast Guy"));  
23.         t1.start();  
24.         Thread t2 = new Thread (new TimePrinter(3000, "Slow Guy"));  
25.         t2.start();  
26.     }  
27. }  

 

 

 

1.3两种线程实现方式的比较

比较内容	继承Thread	使用Runnable接口
启动方式	new一个实例，调用start()方法运行。 例： MyThread extends Thread MyThread Test = new MyThread();  Test.start();	new一个实现Runnable的实例，之后用子类Thread调用。 例： Test impelements Runnable  Test t = new Test();  Thread thread= new Thread(t);   Thread.start();
层次	增加类层次	不增加类层次
继承关系	单继承	利用实现接口，可以达到多继承的效果。还可以再继承其他父类。

*Runnable的实现方式更加灵活。在实际代码中使用的较多的是利用实现Runnable接口的方式来实现线程的。

 

 

 

2.线程安全对象

在Java中有些对象是线程安全的，线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。

对于非线程安全的类和接口，在多线程中需要程序员自己处理线程安全问题。

 

在集合框架中，线程安全的类有：Vector、HashTable、Stack、Enumeration。

除了这些之外，其他的都是非线程安全的类和接口。

 

3.线程状态

 

 线程的状态表示线程正在进行的活动以及在此时间段内所能完成的任务.线程有创建,可运行,运行中,阻塞,死亡五中状态.一个具有生命的线程,总是处于这五种状态之一：
1.创建状态
使用new运算符创建一个线程后,该线程仅仅是一个空对象,系统没有分配资源,称该线程处于创建状态(new thread)
2.可运行状态
使用start()方法启动一个线程后,系统为该线程分配了除CPU外的所需资源,使该线程处于可运行状态(Runnable)
3.运行中状态
Java运行系统通过调度选中一个Runnable的线程,使其占有CPU并转为运行中状态(Running).此时,系统真正执行线程的run()方法.
4.阻塞状态
一个正在运行的线程因某种原因不能继续运行时,进入阻塞状态(Blocked)
5.死亡状态
线程结束后是死亡状态(Dead)

4.同步

使用synchronized进行同步线程同步主要有以下几种方式：

 

4.1通过synchronized块同步非静态方法

 

 

[java] view plain copy

1. class Sync {  
2.     public void method(){  
3.         synchronized(this){//对method方法使用synchronized进行同步  
4.         ... ...  
5.         }  
6.     }   
7. }  

 

4.2使内类的非静态方法和外类的非静态方法同步

[java] view plain copy

1. class Sync {  
2.     class InnerClass{  
3.         public void method(){  
4.             synchronized(Sync.this){   
5.             ... ...  
6.             }  
7.         }  
8.     }   
9. }  

 

4.3静态类方法的同步

[java] view plain copy

1. class Sync {  
2.     public static void method(){  
3.         synchronized(Sync.this){   
4.         ... ...  
5.         }  
6.     }   
7.     public static synchronized void method2(){}  
8. }  

 

4.4同步锁

[java] view plain copy

1. class MyThread_1 extends Thread{  
2. Object lock;  
3. public MyThread_1(Object o){  
4.     lock=o;  
5. }  
6. public void run(){  
7.     try{  
8.         synchronized(lock){  
9.             System.out.println("Enter Thread_1 and wait");  
10.             lock.wait();  
11.             System.out.println("be notified");  
12.         }  
13.     }catch(InterruptedException e){}  
14. }  
15. }  
16.   
17. class MyThread_2 extends Thread{  
18. Object lock;  
19. public MyThread_2(Object o){  
20.     lock=o;  
21. }  
22. public void run(){  
23.     synchronized(lock){  
24.         System.out.println("Enter Thread_2 and notify");  
25.         lock.notify();  
26.     }  
27. }  
28. }  
29.   
30. public class MyThread{   
31. public static void main(String[] args){  
32.     int[] in=new int[0];//notice  
33.     MyThread_1 t1=new MyThread_1(in);  
34.     MyThread_2 t2=new MyThread_2(in);  
35.     t1.start();  
36.     t2.start();  
37.     }  
38. }