关于多线程的一些总结

为了准备华为时找到的一些关于多线程的例子，再次发表一下：

ava中的线程
Java中实现多线程的类有两种方法
1.扩展java.lang.Thread类，用它覆盖Thread类的run方法。
2.生成实现java.lang.Runnable接口的类并将其它的实例与java.lang.Thread实例相关联

Thread类最重要的方法是run方法。run方法是新线程执行的方法

线程的几个重要的时间段： 
·开始线程的初始化 
·线程开始执行main（）瞬间 
·线程开始执行start（）的瞬间 
·start()创建一个新线程并返回main（）的瞬间 
·新线程的初始化 
·新线程开始执行run（）的瞬间 
·每个线程结束的不同瞬间
注意新线程的初始化，它对run（）的执行，和它的结束都与开始线程的执行同时发生。 
警告
一个线程调用start()后，在run（）方法退出前并发调用那方法将导致start()掷出一个java.lang.IllegalThreadStateException对象。

线程间发信
Object 类为此提供了三个函数：wait()、notify() 和 notifyAll()
当对一个线程调用 wait() 时，该线程就被有效阻塞，只到另一个线程对同一个对象调用 notify() 或 notifyAll() 为止

notify仅唤醒一个线程并允许它去获得锁，notifyAll是唤醒所有等待这个对象的线程并允许它们去获得对象锁

在调用wait的时候，线程自动释放其占有的对象锁，同时不会去申请对象锁。当线程被唤醒的时候，它才再次获得了去获得对象锁的权利。

wait就是等待这个对象的同步锁,不过调用这个方法必须先获得这个对象的同步锁

notify:唤醒在等待该对象同步锁的线程

首先是生产者和消费者问题

java 代码

1. class Stor {   
2.     String name = "";   
3.   
4.     boolean full = false;   
5.   
6.     public synchronized void setProduction(String name) {   
7.         while (full) {   
8.             try {   
9.                 this.wait();   
10.             } catch (Exception e) {   
11.                 System.out.println(e.toString());   
12.             }   
13.         }   
14.         full = true;   
15.         System.out.println("ddddddddddddddd");   
16.         this.notify();   
17.   
18.     }   
19.   
20.     public synchronized void getProduction() {   
21.         while (!full) {   
22.             try {   
23.                 this.wait();   
24.             } catch (Exception e) {   
25.                 System.out.println(e.toString());   
26.             }   
27.         }   
28.         full = false;   
29.         System.out.println("ffffffffffffffffff");   
30.         this.notify();   
31.     }   
32. }   
33.   
34. class Custome extends Thread {   
35.     Stor stor;   
36.   
37.     public Custome(Stor stor) {   
38.         this.stor = stor;   
39.     }   
40.   
41.     public void run() {   
42.         while (true) {   
43.             stor.getProduction();   
44.         }   
45.     }   
46. }   
47.   
48. class Productor extends Thread {   
49.     Stor stor;   
50.   
51.     public Productor(Stor stor) {   
52.         this.stor = stor;   
53.     }   
54.   
55.     public void run() {   
56.         while (true) {   
57.             stor.setProduction("test");   
58.         }   
59.     }   
60. }   
61.   
62. public class Product {   
63.     public static void main(String[] arg) {   
64.         Stor stor = new Stor();   
65.         Custome custome = new Custome(stor);   
66.         custome.start();   
67.         Productor productor = new Productor(stor);   
68.         productor.start();   
69.     }   
70. }   

 

一个关于死锁的例子：

java 代码

1. public class Test {   
2.       public static void main(String[] args) {   
3.         final Object resource1 = "resource1";   
4.         final Object resource2 = "resource2";   
5.         // t1 tries to lock resource1 then resource2   
6.         Thread t1 = new Thread() {   
7.           public void run() {   
8.             // Lock resource 1   
9.             synchronized (resource1) {   
10.               System.out.println("Thread 1: locked resource 1");   
11.   
12.               try {   
13.                 Thread.sleep(50);   
14.               } catch (InterruptedException e) {   
15.               }   
16.   
17.               synchronized (resource2) {   
18.                 System.out.println("Thread 1: locked resource 2");   
19.               }   
20.             }   
21.           }   
22.         };   
23.   
24.         // t2 tries to lock resource2 then resource1   
25.         Thread t2 = new Thread() {   
26.           public void run() {   
27.             synchronized (resource2) {   
28.               System.out.println("Thread 2: locked resource 2");   
29.   
30.               try {   
31.                 Thread.sleep(50);   
32.               } catch (InterruptedException e) {   
33.               }   
34.   
35.               synchronized (resource1) {   
36.                 System.out.println("Thread 2: locked resource 1");   
37.               }   
38.             }   
39.           }   
40.         };   
41.   
42.         // If all goes as planned, deadlock will occur,   
43.         // and the program will never exit.   
44.         t1.start();   
45.         t2.start();   
46.       }   
47.     }