JAVA基础（十五）进程通信

悠悠 2022-04-24 08:38 63阅读 0赞

进程通信：实质就是两个线程在操控同一个资源，只是操作的动作不同

等待唤醒机制。

先来看两个方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70][]

wait() notify()这样的方法都使用在同步中，因为要对持有监视器（锁）的线程进行操作。而只有同步才有锁。  
又由于这些方法在操作同步中的线程时，都必须要标识他们所操作那个线程所持有的锁，以保证等待和唤醒的必须是  
同一个锁。而锁可以是任意对象，因此这两个方法定义在Object类中

class Res
    {
        private String name;
    
        private String sex;
    
        boolean flag = false;
    
        public synchronized void set(String name,String sex)
        {
            if(flag)
                try{this.wait();}catch(Exception e){}    //如果有东西，就不让再存了，先睡会吧
    
            this.name = name;           //没东西不走if直接走这里，把东西存进来。
    
            this.sex = sex;
    
            flag = true;        //刚存完要把标记改为true说明里边已经满了。
    
            this.notify();      //已经满了没法存了，唤醒线程池里另一个线程来取。
        }
    
        public synchronized void out()
        {
            if(!flag)
                try{this.wait();}catch(Exception e){}    //如果没有东西就别取了，先睡会吧
    
            System.out.println(name+"........."+sex);    //如果有东西就读这条语句，把东西取出去。
    
            flag = false;               //刚取完要把标记改为false说明里边已经空了。
    
            this.notify();          //里边空了没法取了，唤醒另一个进程往里存吧。
        }
    }
    
    class Input2 implements Runnable
    {
        private Res r;
    
        Input2(Res r)
        {
            this.r = r;
        }
    
        public void run()
        {
            int x = 0;
    
            while(true)
            {
                if(x==0)
                    r.set("jack","man");
    
                else
                    r.set("丽丽","女");
    
                x = (x+1)%2;
            }
        }
    }
    
    class Output2 implements Runnable
    {
        private Res r;
    
        Output2(Res r)
        {
            this.r = r;
        }
    
        public void run()
        {
            while(true)
            {
                r.out();
            }
        }
    }
    
    class ImproveCom
    {
        public static void main(String[] args)
        {
            Res r = new Res();
    
            new Thread(new Input2(r)).start();
    
            new Thread(new Output2(r)).start();
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 3][]

jdk1.5以后，synchronized方法被lock方法所替代，wait() notify()方法被Condition对象所封装。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 4][]

![20190424205831247.png][]

import java.util.concurrent.locks.*;
    
    //jdk1.5以后的改进版生产者消费者
    class Resource15
    {
        private String name;
    
        private int count = 1;
    
        boolean flag = false;
    
        //Lock是一个接口，ReentrantLock是一个实现类，下句是多态。
        private Lock lock = new ReentrantLock(); //一个可重入的互斥锁 Lock
    
        //Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
        private Condition condition_pro = lock.newCondition();
        private Condition condition_cus = lock.newCondition();
    
        public void set(String name)throws InterruptedException
        {
            lock.lock();
            try{
                while(flag)
                    condition_pro.await();
    
                this.name = name + "--" +count++;
    
                System.out.println(Thread.currentThread().getName()+".....生产者..."+this.name);
    
                flag = true;
    
                condition_con.signal();
            }
            finally
            {
                lock.unlock(); //释放一定要在finally中
            }
    }
    
        public void out()throws InterruptedException
        {
            lock.lock();
            try{
                while(!flag)
                    condition_con.await();
    
                System.out.println(Thread.currentThread().getName()+"....消费者.........."+this.name);
    
                flag = false;
    
                condition_pro.signal();
            }
            finally
            {
                lock.unlock();
            }
        }
    }
    
    class mather implements Runnable
    {
        private Resource15 res;
    
        mather(Resource15 res)
        {
            this.res = res;
        }
    
        public void run()
        {
            while(true)
            {
                try{
                    res.set("+商品+");
                }
                catch(InterruptedException e)
                {
    
                }
            }
        }
    }
    
    class pater implements Runnable
    {
        private Resource15 res;
    
        pater (Resource15 res)
        {
            this.res = res ;
        }
    
        public void run()
        {
            while(true)
            {
                try{
                    res.out();
                }
                catch(InterruptedException e)
                {
    
                }
            }
        }
    }
    
    class Test15
    {
        public static void main(String[] args)
        {
            Resource15 r = new Resource15();
    
            new Thread(new mather(r)).start();
            new Thread(new mather(r)).start();
    
            new Thread(new pater(r)).start();
            new Thread(new pater(r)).start();
        }
    }

停止线程的方法：t1.interrupt()，强制停止一个已经在挂起状态的线程。但是会报出一个错。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 5][]

守护线程：t1.setDaemon(ture)当你把某些线程标记为守护（后台线程）后，当所有前台线程都结束后所有后台线程自动终结。把建的线程设为守护线程后，主线程没设，则主线程是前台线程，当主线程结束后所有守护线程停止运行。

join方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 6][]

调用join 方法的线程具有优先执行权

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70]: /images/20220217/083a1b6ffd3b421a9ec95c87f9acee25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 1]: /images/20220217/6f253e128eb04ac999afe8baa55557ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 2]: /images/20220217/5bbad1b18f6e4d298e22a834a8e201f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 3]: /images/20220217/66dc5d686d1f4f62a94b99bb1293f225.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 4]: /images/20220217/c68b572b1f1642afa11c7837ddb0e208.png
[20190424205831247.png]: /images/20220217/9dc80e9e1e4a4e3cbfd9859f98324e2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 5]: /images/20220217/e910901b546e40488cb08797b1f57938.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70 6]: /images/20220217/8856aeec69984e11b3f2e02f71e79709.png