关于多线程的问题

1>多线程的 实现方式     继承Thread类    或者      实现 Runnable  接口

2>出现线程安全的原因（主要讲解 同步锁）

    线程  操作共性数据的多条代码 分开执行，就会引起线程安全问题（关键点：存在共性数据，操作共性数据的多条代码被分开）

    解决方案：保证     操作共性数据的多条代码在同一时间段内 只有一个线程在执行，执行期间，不允许其他线程进入。

    解决问题的方式：
    Java提供了解决方案，就是同步机制。
    代码体现：同步代码块。
    synchronized(对象)//对象可以是任意对象。
    {
        需要被同步封装的语句。
    }

    同步的好处：
    解决了多线程的安全问题。

同步前提：
    1，必须要有两个或者两个以上的线程。
    2，多个线程必须使用同一个锁。

同步的弊端：
    降低运行效率，对资源是一种消耗。

[java] view plain copy

1. class Ticket implements Runnable{  
2.     private int tickets = 10;  
3.     private Object obj = new Object();  
4.     public void run(){  
5.         while(tickets > 0){  
6.             try {  
7.                 synchronized(obj){  
8.                     Thread.sleep(100);  
9.                     if(tickets>0)  
10.                         System.out.println(Thread.currentThread().getName()+"   "+tickets--);  
11.                 }  
12.             } catch (InterruptedException e) {  
13.                 throw new RuntimeException();  
14.             }  
15.         }  
16.     }  
17. }  
18.   
19.   
20. public class TicketDemo {  
21.     public static void main(String[] args) {  
22.         Ticket t = new Ticket();  
23.           
24.         Thread t1 = new Thread(t);  
25.         Thread t2 = new Thread(t);  
26.         Thread t3 = new Thread(t);  
27.         Thread t4 = new Thread(t);  
28.           
29.         t1.start();  
30.         t2.start();  
31.         t3.start();  
32.         t4.start();  
33.           
34.     }  
35. }  

将同步代码块 提取出来 封装为一个方法，同时在该方法 同步（添加synchronized关键字），于是就出现了同步函数。

同步代码块的锁 是 private Object obj = new Object();

同步函数用的锁 是 this。

同步函数和同步代码块的区别：
    同步函数使用的锁是固定的 this。
    同步代码块可以指定任意的对象作为锁。
    一般开发常用同步代码块。

静态同步函数锁使用的锁是：所属类的字节码文件对象 写法 类名.class

验证 使用的 锁 是什么的  方法如下，将同步代码块的锁 

[java] view plain copy

1. class Ticket implements Runnable  
2. {  
3.     private  int ticks = 100;  
4.     Object obj = new Object();  
5.     boolean flag = true;  
6.     public  void run()  
7.     {  
8.         if(flag)      
9.             while(true)  
10.             {  
11.                 synchronized(this)  
12.                 {  
13.                     if(ticks>0)  
14.                     {     
15.                         try{Thread.sleep(10);}catch(InterruptedException e){}  
16.                         System.out.println(Thread.currentThread().getName()+"..code.."+ticks--);  
17.                     }  
18.                 }  
19.             }  
20.         else  
21.             while(true)  
22.                 show();  
23.     }  
24.     public synchronized void show()  
25.     {  
26.         if(ticks>0)  
27.         {  
28.             try{Thread.sleep(10);}catch(InterruptedException e){}  
29.             System.out.println(Thread.currentThread().getName()+"..show funciton.."+ticks--);  
30.         }  
31.     }  
32.   
33. }  
34.   
35.   
36. class ThisLockDemo  
37. {  
38.     public static void main(String[] args)   
39.     {  
40.         Ticket t = new Ticket();  
41.   
42.         Thread t1 = new Thread(t);  
43.         Thread t2 = new Thread(t);  
44.   
45.         t1.start();  
46.         try{Thread.sleep(10);}catch(Exception e){}  
47.         t.flag = false;  
48.         t2.start();  
49.     }  
50. }  

3>关于  死锁的 一个例子

[java] view plain copy

1. class DeadLock implements Runnable{  
2.   
3.     private static Object lockA = new Object();  
4.     private static Object lockB = new Object();  
5.     private boolean flag;  
6.     DeadLock(boolean flag){  
7.         this.flag = flag;  
8.     }  
9.       
10.     public void run() {  
11.         if(flag){  
12.             while(true){  
13.                 synchronized (lockA) {  
14.                     System.out.println("   if ------- lockA       ");  
15.                     synchronized (lockB) {  
16.                         System.out.println("   if ------- lockB       ");  
17.                     }  
18.                 }  
19.             }  
20.         }else{  
21.             while(true){  
22.                 synchronized (lockB) {  
23.                     System.out.println("   else ------- lockB       ");  
24.                     synchronized (lockA) {  
25.                         System.out.println("   else ------- lockA       ");  
26.                     }  
27.                 }  
28.             }  
29.         }  
30.     }  
31.       
32. }  
33.   
34.   
35. public class DeadLockDemo {  
36.     public static void main(String[] args) {  
37.         DeadLock t1 = new DeadLock(true);  
38.         DeadLock t2 = new DeadLock(false);  
39.           
40.         Thread tt1 = new Thread(t1);  
41.         Thread tt2 = new Thread(t2);  
42.         tt1.start();  
43.         tt2.start();  
44.           
45.     }  
46. }  

注意上面代码中使用的锁，是static的，保证t1和t2使用的是相同的   lockA和lockB