多线程sleep,yield,wait区别

sleep()
1)    sleep ()函数有一个参数，通过参数可使线程在指定的时间内进入停滞状态，当指定的时间过后，线程则自动进入可执行状态。
2)    当调用sleep ()函数后，线程不会释放它的“锁标志”。

class TestThreadMethod extends Thread{ 
        class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public synchronized void run(){ 
            for(int i=0; i<3; i++){ 
                System.out.print(Thread.currentThread().getName()); 
                System.out.println(" : " + i); 
                try{ 
                    Thread.sleep(100);　//（4） 
                } 
                catch(InterruptedException e){ 
                    System.out.println("Interrupted"); 
                } 
            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            TestThreadMethod t2 = new TestThreadMethod("t2"); 
            t1.start();　（1） 
            t1.start();　（2） 
            //t2.start();　（3） 
        } 
} 

运行结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 0
t1 : 1
t1 : 2


由结果可证明，虽然在run()中执行了sleep()，但是它不会释放对象的“锁标志”，所以除非代码(1)的线程执行完run()函数并释放对象的“锁标志”，否则代码（2）的线程永远不会执行。
                 如果把代码（2）注释掉，并去掉代码（3）的注释，结果将变为：
t1 : 0
t2 : 0
t1 : 1
t2 : 1
t1 : 2
t2 : 2
由于t1和t2是两个对象的线程，所以当线程t1通过sleep()进入停滞时，排程器会从线程池中调用其它的可执行线程，从而t2线程被启动

class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public synchronized void run(){ 
            for(int i=0; i<5; i++){ 
                System.out.print(Thread.currentThread().getName()); 
                System.out.println(" : " + i); 
                try{ 
                    if(Thread.currentThread().getName().equals("t1")) 
                        Thread.sleep(200); 
                    else 
                        Thread.sleep(100); 
                } 
                catch(InterruptedException e){ 
                    System.out.println("Interrupted"); 
                } 
            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            TestThreadMethod t2 = new TestThreadMethod("t2"); 
            t1.start(); 
            //t1.start(); 
            t2.start(); 
        } 
    } 

运行结果为：
t1 : 0
t2 : 0
t2 : 1
t1 : 1
t2 : 2
t2 : 3
t1 : 2
t2 : 4
t1 : 3
t1 : 4
由于线程t1调用了sleep(200)，而线程t2调用了sleep(100)，所以线程t2处于停滞状态的时间是线程t1的一半，从从结果反映出来的就是线程t2打印两倍次线程t1才打印一次。


yield() 


1)    通过yield ()函数，可使线程进入可执行状态，排程器从可执行状态的线程中重新进行排程。所以调用了yield()的函数也有可能马上被执行。
2)    当调用yield ()函数后，线程不会释放它的“锁标志”。

class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public synchronized void run(){ 
            for(int i=0; i<4; i++){ 
                System.out.print(Thread.currentThread().getName()); 
                System.out.println(" : " + i); 
                Thread.yield(); 
            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            TestThreadMethod t2 = new TestThreadMethod("t2"); 
            t1.start(); 
            t1.start();　//（1） 
            //t2.start();　（2） 
        } 
} 

运行结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 0
t1 : 1
t1 : 2
t1 : 3
从结果可知调用yield()时并不会释放对象的“锁标志”。
                如果把代码（1）注释掉，并去掉代码（2）的注释，结果为：
t1 : 0
t1 : 1
t2 : 0
t1 : 2
t2 : 1
t1 : 3
t2 : 2
t2 : 3
从结果可知，虽然t1线程调用了yield()，但它马上又被执行了。


sleep()和yield()的区别

1)    sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
2)    sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。

class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public void run(){ 
            for(int i=0; i<4; i++){ 
                System.out.print(Thread.currentThread().getName()); 
                System.out.println(" : " + i); 
                //Thread.yield();　（1） 
                /* （2） */ 
                try{ 
                    Thread.sleep(3000); 
                } 
                catch(InterruptedException e){ 
                    System.out.println("Interrupted"); 
                } 

            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            TestThreadMethod t2 = new TestThreadMethod("t2"); 
            t1.setPriority(Thread.MAX_PRIORITY); 
            t2.setPriority(Thread.MIN_PRIORITY); 
            t1.start(); 
            t2.start(); 
        } 
} 

运行结果为：
t1 : 0
t1 : 1
t2 : 0
t1 : 2
t2 : 1
t1 : 3
t2 : 2
t2 : 3
由结果可见，通过sleep()可使优先级较低的线程有执行的机会。注释掉代码（2），并去掉代码（1）的注释，结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t2 : 0
t2 : 1
t2 : 2
t2 : 3
可见，调用yield()，不同优先级的线程永远不会得到执行机会。

join()


使调用join()的线程执行完毕后才能执行其它线程，在一定意义上，它可以实现同步的功能。

class TestThreadMethod extends Thread{ 
        public static int shareVar = 0; 
        public TestThreadMethod(String name){ 
            super(name); 
        } 
        public void run(){ 
            for(int i=0; i<4; i++){ 
                System.out.println(" " + i); 
                try{ 
                    Thread.sleep(3000); 
                } 
                catch(InterruptedException e){ 
                    System.out.println("Interrupted"); 
                } 
            } 
        } 
    } 
    public class TestThread{ 
        public static void main(String[] args){ 
            TestThreadMethod t1 = new TestThreadMethod("t1"); 
            t1.start(); 
            try{ 
                t1.join(); 
            } 
            catch(InterruptedException e){} 
            t1.start(); 
        } 
} 

运行结果为：
0
1
2
3
0
1
2
3