关于多线程

题目：请编写一个多线程程序，实现两个线程，其中一个线程完成对某个对象的int成员变量的增加操作，即每次加1，另一个线程完成对该对象的成员变量的减操作，即每次减1，同时要保证该变量的值不会小于0，不会大于1，该变量的初始值为0.

即要求输出结果是0101010101010101这样的形式

关于wait,notify,notifyAll以及sleep方法的关系（重点）

1 如果一个线程调用了某个对象的wait方法，那么该线程首先必须要有该对象的锁（换句话说，一个线程调用了某个对象的wait方法，你们该wait方法必须要在synchronized中）

2 如果一个线程调用了某个对象的wait方法，那么该线程就会释放该对象的锁

3 在java对象中，有两种池（锁池，等待池）

4 如果一个线程调用了某个对象的wait方法，那么该线程进入该对象的等待池中（释放锁），如果未来的某一时刻，另外一个线程调用了相同的对象的notify或notifyall方法，那么在该等待池中的等待的线程就会起来进入该对象的锁池中，去等待获得该对象的锁，如果获得锁成功后，那么该线程将继续沿着wait方法之后的路径去执行。

5 sleep(long time)，如果一个线程调用了sleep方法睡眠，那么在睡眠的同时，它不会失去对象的锁的拥有权。

 

关于synchronized关键字的作用

1 在某个对象的所有synchronized方法中，在某一时刻，只能有一个唯一的一个线程去访问这些synchronized方法

2 如果一个方法是synchronized方法，那么该synchronized关键字表示给当前对象上锁（即this）

3 如果一个synchronized方法是静态的（static的），那么该synchronized关键字表示给当前对象所对应的Class对象上锁。（每个类，不管生成多少对象，其Class对象只有一个）

 

代码示例一、

java 代码

1. package com.test.thread;   
2.   
3. public class Sample {   
4.     private int number;   
5.        
6.        
7.     public synchronized void increate()   
8.     {   
9.         while(number>0)   
10.         {   
11.             try {   
12.                 wait();   
13.             } catch (InterruptedException e) {   
14.                 e.printStackTrace();   
15.             }   
16.         }   
17.         number++;   
18.         System.out.println(number);   
19.         notify();   
20.     }   
21.        
22.        
23.     public synchronized void decreate()   
24.     {   
25.         while(number==0)   
26.         {   
27.             try {   
28.                 wait();   
29.             } catch (InterruptedException e) {   
30.                 e.printStackTrace();   
31.             }   
32.         }   
33.         number--;   
34.         System.out.println(number);   
35.         notify();   
36.     }   
37.        
38.        
39. }   

 

java 代码

1. package com.test.thread;   
2.   
3. public class IncreateThread extends Thread {   
4.   
5.     private Sample sample;   
6.        
7.     public IncreateThread(Sample sample)   
8.     {   
9.         this.sample = sample;   
10.     }   
11.        
12.        
13.     @Override  
14.     public void run() {   
15.            
16.         for(int i=0;i<5;i++)   
17.         {   
18.             try {   
19.                 Thread.sleep(1000);   
20.             } catch (InterruptedException e) {   
21.                 e.printStackTrace();   
22.             }   
23.                
24.             sample.increate();             
25.         }   
26.            
27.     }   
28.   
29. }   

 

java 代码

1. package com.test.thread;   
2.   
3. public class DecreateThread extends Thread {   
4.   
5.     private Sample sample;   
6.        
7.     public DecreateThread(Sample sample)   
8.     {   
9.         this.sample = sample;   
10.     }   
11.        
12.        
13.     @Override  
14.     public void run() {   
15.            
16.         for(int i=0;i<5;i++)   
17.         {   
18.             try {   
19.                 sleep(1000);   
20.             } catch (InterruptedException e) {   
21.                 e.printStackTrace();   
22.             }   
23.                
24.             sample.decreate();   
25.                
26.         }   
27.            
28.            
29.     }   
30.   
31. }   

 

java 代码

1. package com.test.thread;   
2.   
3. public class TestThread {   
4.   
5.     /**  
6.      * @param args  
7.      */  
8.     public static void main(String[] args) {   
9.            
10.         Sample sample = new Sample();   
11.            
12.         Thread thread1 = new IncreateThread(sample);   
13.         Thread thread2 = new DecreateThread(sample);   
14.            
15.         Thread thread3 = new IncreateThread(sample);   
16.         Thread thread4 = new DecreateThread(sample);   
17.            
18.         thread1.start();   
19.         thread2.start();   
20.         thread3.start();   
21.         thread4.start();   
22.   
23.     }   
24.   
25. }