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=;
    private String name;
    public Thread1(String name) {
       this.name=name;
    }
    public void run() {
        for (int i = ; i < ; i++) {
            System.out.println(name + "运行  count= " + count--);
            try {
                sleep((int) Math.random() * );
            } 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=;
            while (i>){
                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();
    }
}