Thread和Object类中的重要方法详解

雨点打透心脏的1/2处 2021-09-24 02:24 329阅读 0赞

## 方法概览 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70]  
**Wait 和 Notify**

package threadcoreknowledge.threadobjectclasscommonmethods;
    
    /** * 描述： 展示wait和notify的基本用法 1. 研究代码执行顺序 2. 证明wait释放锁 */
    public class Wait { 
    
        public static Object object = new Object();
    
        static class Thread1 extends Thread { 
    
            @Override
            public void run() { 
                synchronized (object) { 
                    System.out.println(Thread.currentThread().getName() + "开始执行了");
                    try { 
                        object.wait();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() + "获取到了锁。");
                }
            }
        }
    
        static class Thread2 extends Thread { 
    
            @Override
            public void run() { 
                synchronized (object) { 
                    object.notify();
                    System.out.println("线程" + Thread.currentThread().getName() + "调用了notify()");
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread1 thread1 = new Thread1();
            Thread2 thread2 = new Thread2();
            thread1.start();
            Thread.sleep(200);
            thread2.start();
        }
    }

**Wait 和 Notify**

package threadcoreknowledge.threadobjectclasscommonmethods;
    
    /** * 描述： 3个线程，线程1和线程2首先被阻塞，线程3唤醒它们。notify, notifyAll。 start先执行不代表线程先启动。 */
    public class WaitNotifyAll implements Runnable { 
    
        private static final Object resourceA = new Object();
    
    
        public static void main(String[] args) throws InterruptedException { 
            Runnable r = new WaitNotifyAll();
            Thread threadA = new Thread(r);
            Thread threadB = new Thread(r);
            Thread threadC = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    synchronized (resourceA) { 
                        resourceA.notifyAll();
    // resourceA.notify();
                        System.out.println("ThreadC notified.");
                    }
                }
            });
            threadA.start();
            threadB.start();
    // Thread.sleep(200);
            threadC.start();
        }
        @Override
        public void run() { 
            synchronized (resourceA) { 
                System.out.println(Thread.currentThread().getName()+" got resourceA lock.");
                try { 
                    System.out.println(Thread.currentThread().getName()+" waits to start.");
                    resourceA.wait();
                    System.out.println(Thread.currentThread().getName()+"'s waiting to end.");
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

## 生产者和消费者模式(wait、notify、notifyAll的一大用处) ##

**1、为什么使用这种模式？可以解决什么问题？**

在线程的世界中、生产者就是生产一些数据、消费者就是把这些数据使用出来、但是他们的速度很有可能是不一致的。有的时候是生产者快、有的时候是生产者慢。而生产者和消费者模式就解决了他们之间相互等待的问题，而不至于一个过快，一个过慢，相互配合困难。实际上是将生产者和消费者进行了解耦。从而使他们可以流畅的配合。  
**（用wait和notify来进行代码实现，不允许使用阻塞队列）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 1]  
**2、用wait和notify来进行代码实现，不允许使用阻塞队列**

package threadcoreknowledge.threadobjectclasscommonmethods;
    
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.LinkedList;
    import java.util.List;
    
    /** * 描述： 用wait/notify来实现生产者消费者模式 */
    public class ProducerConsumerModel { 
        public static void main(String[] args) { 
            EventStorage eventStorage = new EventStorage();
            Producer producer = new Producer(eventStorage);
            Consumer consumer = new Consumer(eventStorage);
            new Thread(producer).start();
            new Thread(consumer).start();
        }
    }
    
    class Producer implements Runnable { 
    
        private EventStorage storage;
    
        public Producer(
                EventStorage storage) { 
            this.storage = storage;
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                storage.put();
            }
        }
    }
    
    class Consumer implements Runnable { 
    
        private EventStorage storage;
    
        public Consumer(
                EventStorage storage) { 
            this.storage = storage;
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                storage.take();
            }
        }
    }
    
    class EventStorage { 
    
        private int maxSize;
        private LinkedList<Date> storage;
    
        public EventStorage() { 
            maxSize = 10;
            storage = new LinkedList<>();
        }
    
        public synchronized void put() { 
            while (storage.size() == maxSize) { 
                try { 
                    wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            storage.add(new Date());
            System.out.println("仓库里有了" + storage.size() + "个产品。");
            notify();
        }
    
        public synchronized void take() { 
            while (storage.size() == 0) { 
                try { 
                    wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            System.out.println("拿到了" + storage.poll() + "，现在仓库还剩下" + storage.size());
            notify();
        }
    }

# wait、notify、notifyAll常见面试问题。 #

![20200331101500222.png][]

## 有两种实现的思路 ##

**1、用synchronized关键字实现**

package threadcoreknowledge.threadobjectclasscommonmethods;
    
    /** * 描述： 两个线程交替打印0~100的奇偶数，用synchronized关键字实现 */
    public class WaitNotifyPrintOddEvenSyn { 
    
        private static int count;
    
        private static final Object lock = new Object();
    
        //新建2个线程
        //1个只处理偶数，第二个只处理奇数（用位运算）
        //用synchronized来通信
        public static void main(String[] args) { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    while (count < 100) { 
                        synchronized (lock) { 
                            if ((count & 1) == 0) { 
                                System.out.println(Thread.currentThread().getName() + ":" + count++);
                            }
                        }
                    }
                }
            }, "偶数").start();
    
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    while (count < 100) { 
                        synchronized (lock) { 
                            if ((count & 1) == 1) { 
                                System.out.println(Thread.currentThread().getName() + ":" + count++);
                            }
                        }
                    }
                }
            }, "奇数").start();
        }
    }

**2、用wait和notify实现**

package threadcoreknowledge.threadobjectclasscommonmethods;
    
    
    /** * 描述： 两个线程交替打印0~100的奇偶数，用wait和notify */
    public class WaitNotifyPrintOddEveWait { 
    
        private static int count = 0;
        private static final Object lock = new Object();
    
    
        public static void main(String[] args) { 
            new Thread(new TurningRunner(), "偶数").start();
            new Thread(new TurningRunner(), "奇数").start();
        }
    
        //1. 拿到锁，我们就打印
        //2. 打印完，唤醒其他线程，自己就休眠
        static class TurningRunner implements Runnable { 
    
            @Override
            public void run() { 
                while (count <= 100) { 
                    synchronized (lock) { 
                        //拿到锁就打印
                        System.out.println(Thread.currentThread().getName() + ":" + count++);
                        lock.notify();
                        if (count <= 100) { 
                            try { 
                                //如果任务还没结束，就让出当前的锁，并休眠
                                lock.wait();
                            } catch (InterruptedException e) { 
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 3]

## sleep方法详解 ##

**特点1：不释放锁。需要手动释放。只有当sleeop时间到了才会释放锁**

**特点2：响应中断**

一旦线程中断了就会：

1、抛出InterruptException

2、清除中断状态。

package threadcoreknowledge.threadobjectclasscommonmethods;
    
    import java.util.Date;
    import java.util.concurrent.TimeUnit;
    
    /** * 描述： 每个1秒钟输出当前时间，被中断，观察。 * Thread.sleep() * TimeUnit.SECONDS.sleep() */
    public class SleepInterrupted implements Runnable{ 
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new SleepInterrupted());
            thread.start();
            Thread.sleep(6500);
            thread.interrupt();
        }
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                System.out.println(new Date());
                try { 
                    TimeUnit.HOURS.sleep(3);
                    TimeUnit.MINUTES.sleep(25);
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) { 
                    System.out.println("我被中断了！");
                    e.printStackTrace();
                }
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 4]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70]: /images/20210923/5959e0f2a98042f2ac83173cd9dd4b40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 1]: /images/20210923/7e7a9b3f82b04f9585f02dbc7447e6c9.png
[20200331101500222.png]: /images/20210923/618e060a4fa7408b89e80a49d70b075f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 2]: /images/20210923/f3b736b6e7704b61a9c50ac89b7df922.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 3]: /images/20210923/b643eb81d2ec4cd19de775a3ac00850f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 4]: /images/20210923/c1eb31597f764575bbf00be86e4cbf37.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 5]: /images/20210923/ea15a6f515df410f9a48802b5fcb8b67.png