线程之wait()/notify()/notifyAll()/sleep()/join()/yield()

wait()/notify()/notifyAll()

• 方法来自object类，必须在synchronized中执行，否则会抛异常

• wait（）

  • 调用该方法会使当前线程处于等待唤醒状态，释放对象锁以及占用的资源，交给其它线程使用,该线程会加入等待唤醒队列中，

• notify()/notifyAll()

  • 用于从等待唤醒队列中唤醒线程。notify（）是唤醒队列中的头一个；notifyAll（）会会唤醒队列中的所有线程，但是哪个线程先执行，这个是不确定的。

       	final String str = new String("王龙");
       	        Thread t1 = new Thread(new Runnable() {
       	            @Override
       	            public void run() {
       	                synchronized (str){
       	                    try {
       	                        for (int i = 0 ; i<10 ; i++) {
       	                            Thread.sleep(1000);
       	                            Log.e(str,"线程1"+i);
       	                            if (i==5){
       	                                person.wait();
       	                            }
       	                        }
       	                    } catch (InterruptedException e) {
       	                        e.printStackTrace();
       	                    }
       	                }
       	            }
       	        },"Thread1");
       	        Thread t2 = new Thread(new Runnable() {
       	            @Override
       	            public void run() {
       	                synchronized (person){
       	                    try {
       	                        for ( int i = 0 ; i < 10 ; i++ ){
       	                            Thread.sleep(1000);
       	                            Log.e(str,"线程2"+i);
       	                            if (i==5){
       	                                person.notify();
       	                            }
       	                        }
       	                    } catch (InterruptedException e) {
       	                        e.printStackTrace();
       	                    }
       	
       	                }
       	            }
       	        },"Thread2");
       	        t1.start();
       	        t2.start();
    

• 线程1先执行，线程2处于等待状态；线程1会循环遍历，当i5的时候，调用wait（）方法，使线程1处于等待状态，这时候线程2会获取资源使用权，执行循环遍历，当i5时，让线程1从等待唤醒队列中唤醒，但是当前线程2任然占用资源使用权，所以会继续实现线程2 的循环遍历，当线程2执行完成之后，就会轮到线程1执行

sleep() 休眠

• 方法来自Thread类，调用该方法使该线程休眠指定的时间，休眠指定的时间后继续执行，该线程并没有释放对象锁，会释放资源使用权

     Thread(Runnable {
                Log.i("Main","子线程1")
                Thread.sleep(10000)
               Log.i("Main","休眠")
            }).start()
    
    Thread(Runnable {
                Log.i("Main","子线程2")
            }).start()
  
  
    //打印结果 
    03-21 07:22:01.300 2028-2041/project.com.tinkertest.debug I/Main: 子线程1
    03-21 07:22:01.308 2028-2042/project.com.tinkertest.debug I/Main: 子线程2
    03-21 07:22:02.896 548-563/system_process I/ActivityManager: Displayed project.com.tinkertest.debug/project.com.tinkertest.MainActivity: +1s795ms
    03-21 07:22:11.303 2028-2041/project.com.tinkertest.debug I/Main: 休眠
  

join() 阻塞

• 方法来自Thread类,调用该方法会让指定的线程先执行，然后执行其他线程。

       val thread1= Thread(Runnable {
             Log.i("Main","子线程1")
             Thread.sleep(10000)
            Log.i("Main","休眠")
         })
         thread1.start()
         thread1.join()
  
         Log.i("Main","主线程需要等待")
        val thread2= Thread(Runnable {
             Log.i("Main","子线程2")
         })
         thread2.start()
         thread2.join()
         Log.i("Main","主线程")
  
     //打印结果
     03-21 08:03:31.724 2426-2439/project.com.tinkertest.debug I/Main: 子线程1
     03-21 08:03:41.724 2426-2439/project.com.tinkertest.debug I/Main: 休眠
     03-21 08:03:41.724 2426-2426/project.com.tinkertest.debug I/Main: 主线程需要等待
     03-21 08:03:41.724 2426-2444/project.com.tinkertest.debug I/Main: 子线程2
     03-21 08:03:41.724 2426-2426/project.com.tinkertest.debug I/Main: 主线程
  

yield() 礼让

• 本地方法，调用该方法会让线程进入就绪状态，当前线程会让出资源，将资源交给其他线程使用，通常是交给优先级别相同或者优先级别较高线程。至于当前线程什么时候再次获取资源用于使用权是不确定的。

   	     val thread1= MyThread()
   	        val thread2=MyThread()
   	        thread1.start()
   	        thread2.start()
  
   	
   	    class  MyThread : Thread(){
   	
   	        override fun run() {
   	            super.run()
   	            for (i in 0 .. 100) {
   	                Log.i("Main",getName() + "在运行，i的值为：" + i + " 优先级为：" + getPriority());
   	                if (i == 2) {
   	                    Log.i("Main",getName() + "礼让");
   	                    Thread.yield();
   	                    try {
   	                        Thread.sleep(1000);
   	                    }catch (e:InterruptedException){
   	                        e.printStackTrace();
   	                    }}
   	
   	                }
   	        }
   	    }
  
       //打印日志
   	03-21 08:59:22.394 2688-2701/project.com.tinkertest.debug I/Main: Thread-126在运行，i的值为：0 优先级为：5
   	03-21 08:59:22.394 2688-2701/project.com.tinkertest.debug I/Main: Thread-126在运行，i的值为：1 优先级为：5
   	03-21 08:59:22.394 2688-2701/project.com.tinkertest.debug I/Main: Thread-126在运行，i的值为：2 优先级为：5
   	03-21 08:59:22.394 2688-2701/project.com.tinkertest.debug I/Main: Thread-126礼让
   	03-21 08:59:22.394 2688-2702/project.com.tinkertest.debug I/Main: Thread-127在运行，i的值为：0 优先级为：5
   	03-21 08:59:22.394 2688-2702/project.com.tinkertest.debug I/Main: Thread-127在运行，i的值为：1 优先级为：5
   	03-21 08:59:22.394 2688-2702/project.com.tinkertest.debug I/Main: Thread-127在运行，i的值为：2 优先级为：5
   	03-21 08:59:22.394 2688-2702/project.com.tinkertest.debug I/Main: Thread-127礼让
   	03-21 08:59:23.394 2688-2701/project.com.tinkertest.debug I/Main: Thread-126在运行，i的值为：3 优先级为：5
   	03-21 08:59:23.394 2688-2701/project.com.tinkertest.debug I/Main: Thread-126在运行，i的值为：4 优先级为：5
   	03-21 08:59:23.394 2688-2701/project.com.tinkertest.debug I/Main: Thread-126在运行，i的值为：5 优先级为：5
  

• 首先线程1执行，当i2，线程1进入就绪状态，将资源交给线程2，线程2执行，当i2时，在将使用权交给线程1，执行后续循环，最后再执行线程2