java多線程注意事項

1:繼承thread和實現Runnable創建線程的區別：
 繼承thread創建的對象直接start（）就可以就緒，但是使用Runnable所new出來的對象要先new Thread(xx)才能start（）
 這也就意味着在start()之前實現Runnable的類一次new 出來的對象是可以多次傳入new Thread()創建多個線程實例並且多次start()的,就是說
 runnable的數據可以被共享，但是繼承thread創建的線程不具備這個功能。

class Thread1 extends Thread{  
    private int count=5;  
    private String name;  
    public Thread1(String name) {  
       this.name=name;  
    }  
    public void run() {  
        for (int i = 0; i < 5; i++) {  
            System.out.println(name + "運行  count= " + count--);  
            try {  
                sleep((int) Math.random() * 10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
         
    }  
}  
  
public class Main {  
  
    public static void main(String[] args) {  
        Thread1 mTh1=new Thread1("A");  
        Thread1 mTh2=new Thread1("B");  
        mTh1.start();  
        mTh2.start();  
  
    }  
  
}  

2：線程的狀態：

           |-阻塞- |
           |      |
    就緒-可運行-運行中-死亡
            |     / |
          |    /  |
          鎖------等待

 

運行---可運行：thread.yield()
運行--等待：object.wait()
運行--阻塞：thread.sleep() thread.join()
運行--鎖：synchronized
等待--鎖：object.notify() 或者wait時間到
鎖--可運行：

3:解析sleep() wait() yield()的區別：

                sleep                        wait                      yield
所屬類：        Thread                     Object                     Thread
目的：            運行到阻塞                    運行到等待               　　 運行到可運行或者立即重新運行
鎖持有狀態：    不釋放                          釋放                    　　　　釋放
讓出cpu資源后:   允許比自己優先級低的運行                            　　　　　只允許比自己優先級高或等的執行，也可能自己去執行
使用條件:        任何地方                   　　必須在同步塊或者方法中 

4：常用方法
 　 sleep(): 強迫一個線程睡眠Ｎ毫秒。
　　isAlive(): 判斷一個線程是否存活。
　　join(): 等待線程終止。
　　activeCount(): 程序中活躍的線程數。
　　enumerate(): 枚舉程序中的線程。
    currentThread(): 得到當前線程。
　　isDaemon(): 一個線程是否為守護線程。
　　setDaemon(): 設置一個線程為守護線程。(用戶線程和守護線程的區別在於，是否等待主線程依賴於主線程結束而結束)
　　setName(): 為線程設置一個名稱。
　　wait(): 強迫一個線程等待。
　　notify(): 通知一個線程繼續運行。
　　setPriority(): 設置一個線程的優先級。

5:synchronized

a:    Public synchronized void methodAAA()//修飾靜態方法時鎖對象是調用這個方法的對象
    {

    //….

    }
b:public void method3(SomeObject so)//修飾塊時鎖對象是括號中的對象
    {
        synchronized(so)
        {
       //…..
        }
    }
c: Class Foo{
    public synchronized static void methodAAA()   // 同步的static 函數鎖對象是當前類
    {
    }
    public void methodBBB()

    {

           synchronized(Foo.class)   // 等同於上面 

    }

       }

6：經典例子

public class Test {
    public  class myThread implements Runnable{
        private String threadName;
        private Object pre;
        private Object curr;
        public  myThread(String n,Object p,Object c){
            this.threadName=n;
            this.pre=p;
            this.curr=c;
        }
        public void run() {
            // TODO Auto-generated method stub
            int i=10;
            while (i>0){
                synchronized(pre){
                    synchronized(curr){
                        System.out.println(threadName);
                        i--;
                        curr.notify();//通知下一個對象獲得鎖
                    }
                    try {
                        pre.wait();
                    }catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }//釋放對pre對象持有的鎖
                }
            }
        }
    }
    public static void main(String[] args){
        Object a=new Object();
        Object b=new Object();
        Object c=new Object();
        Test t=new Test();
        myThread pa=t.new myThread("A",c,a);
        new Thread(pa).start();
        myThread pb=t.new myThread("B",a,b);
        new Thread(pb).start();
        myThread pc=t.new myThread("C",b,c);
        new Thread(pc).start();
    }
}