码迷，mamicode.com
首页 > 编程语言 > 详细

【Java并发】线程通信

时间：2019-10-09 16:06:58      阅读：101      评论：0      收藏：0      [点我收藏+]

标签：boolean   strong   handle   out   注意   机制   sleep   指定   读取   

一、概述

1.1 什么是多线程之间通讯？

  • 多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。

1.2 案例

  • 需求:第一个线程写入(input)用户，另一个线程取读取(out)用户。实现读一个，写一个操作。

代码实现

/**
 * 测试等待/通知机制
 * @author hao
 *
 */
public class Test_NoWaitNotify {
    public static void main(String[] args) {
        Res res = new Res();
        IntThrad intThrad = new IntThrad(res);
        OutThread outThread = new OutThread(res);
        intThrad.start();
        outThread.start();
    }
}

/*
 * 共享资源源实体类
 * 
 */
class Res {
    public String userSex;
    public String userName;
}

/*
 * 
 * 输入线程资源
 * 
 */

class IntThrad extends Thread {
    private Res res;

    public IntThrad(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        int count = 0;
        while (true) {
            if (count == 0) {
                res.userName = "小明";
                res.userSex = "男";
            } else {
                res.userName = "小红";
                res.userSex = "女";
            }
            count = (count + 1) % 2;
        }
    }
}

/*
 * 
 * 输出线程
 * 
 */

class OutThread extends Thread {
    private Res res;

    public OutThread(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println(res.userName + "--" + res.userSex);
        }
    }
}
  • 改例中数据发生错乱，造成线程安全问题

解决线程安全问题

加入synchronized 关键字

public class Test002 {
    public static void main(String[] args) {
        Res2 res = new Res2();
        IntThrad2 intThrad = new IntThrad2(res);
        OutThread2 outThread = new OutThread2(res);
        intThrad.start();
        outThread.start();
    }
}

/*
 * 共享资源源实体类
 * 
 */
class Res2 {
    public String userSex;
    public String userName;
}

/*
 * 
 * 输入线程资源
 * 
 */

class IntThrad2 extends Thread {
    private Res2 res;

    public IntThrad2(Res2 res) {
        this.res = res;
    }

    @Override
    public void run() {
        int count = 0;
        while (true) {
            synchronized (res) {
                if (count == 0) {
                    res.userName = "小明";
                    res.userSex = "男";
                } else {
                    res.userName = "小红";
                    res.userSex = "女";
                }
                count = (count + 1) % 2;
            }
        }
    }
}

/*
 * 
 * 输出线程
 * 
 */

class OutThread2 extends Thread {
    private Res2 res;

    public OutThread2(Res2 res) {
        this.res = res;
    }

    @Override
    public void run() {

        while (true) {
            synchronized (res) {
                System.out.println(res.userName + "--" + res.userSex);
            }
        }
    }
}

二、等待通知机制

2.1 示例

  • 上面例子中解决了线程安全问题，但是如果我们要求读一个写一个，那么该如何解决
  • 1.因为涉及到对象锁,他们必须都放在synchronized中来使用. Wait、Notify一定要在synchronized里面进行使用。
  • 2.Wait必须暂定当前正在执行的线程,并释放资源锁,让其他线程可以有机会运行
  • 3.notify/notifyall: 唤醒因锁池中的线程,使之运行
  • 注意:一定要在线程同步中使用,并且是同一个锁的资源
class Res3 {
    public String userSex;
    public String userName;
    // 线程通讯标识
    public boolean flag = false;
}

class IntThrad3 extends Thread {
    private Res3 res;

    public IntThrad3(Res3 res) {
        this.res = res;
    }

    @Override
    public void run() {
        int count = 0;
        while (true) {
            synchronized (res) {
                if (res.flag) {
                    try {
                        // 当前线程变为等待，但是可以释放锁
                        res.wait();
                    } catch (Exception e) {

                    }
                }
                if (count == 0) {
                    res.userName = "小明";
                    res.userSex = "男";
                } else {
                    res.userName = "小红";
                    res.userSex = "女";
                }
                count = (count + 1) % 2;
                res.flag = true;
                // 唤醒当前线程
                res.notify();
            }

        }
    }
}

class OutThread3 extends Thread {
    private Res3 res;

    public OutThread3(Res3 res) {
        this.res = res;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (res) {
                if (!res.flag) {
                    try {
                        res.wait();
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                }
                System.out.println(res.userName + "--" + res.userSex);
                res.flag = false;
                res.notify();
            }
        }
    }
}

public class Test003 {
    public static void main(String[] args) {
        Res3 res = new Res3();
        IntThrad3 intThrad = new IntThrad3(res);
        OutThread3 outThread = new OutThread3(res);
        intThrad.start();
        outThread.start();
    }
}

2.2 wait与sleep区别

  • 对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。
  • sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。
  • 在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的线程等待池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备，获取对象锁进入运行状态。

三、Lock锁

3.1 概述

  • 在 jdk1.5 之后，并发包中新增了 Lock 接口(以及相关实现类)用来实现锁功能，Lock 接口提供了与 synchronized 关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。

  • Lock写法，基本用法

Lock lock  = new ReentrantLock();
lock.lock();
try{
//可能会出现线程安全的操作
}finally{
//一定在finally中释放锁
//也不能把获取锁在try中进行，因为有可能在获取锁的时候抛出异常
  lock.ublock();
}

3.2 等待/通知机制(Condition)

  • Condition的功能类似于在传统的线程技术中的,Object.wait()和Object.notify()的功能。

  • 代码示例，将上面将的例子改造如下

public class TL002_Condition {
    public static void main(String[] args) throws InterruptedException {

        Res res = new Res();
        IntThread intThread = new IntThread(res);
        OutThread outThread = new OutThread(res);
        intThread.start();
        outThread.start();
    }
}

/*
 * 共享资源
 */
class Res {

    public String name;
    public String sex;
    public boolean flag = false;
    public Lock lock = new ReentrantLock();
    public Condition condition=lock.newCondition();
}

/*
 * 写入线程
 */
class IntThread extends Thread {
    public Res res;

    public IntThread(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        int count = 0; // 1
        while (true) {
            try {
                res.lock.lock();
                if(res.flag){
                    res.condition.await();
                }
                if (count == 0) {
                    res.name = "小明";
                    res.sex = "男";
                } else {
                    res.name = "小红";
                    res.sex = "女";
                }
                count = (count + 1) % 2;
                res.flag=true;
                res.condition.signal();
            } catch (Exception e) {
            } finally {
                res.lock.unlock();
            }

        }

    }

}

// 读取线程
class OutThread extends Thread {

    public Res res;

    public OutThread(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        while (true) {

            try {
                res.lock.lock();
                if(!res.flag){
                    res.condition.await();
                }
                Thread.sleep(1000);
                System.out.println(res.name + "," + res.sex);
                res.flag = false;
                res.condition.signal();
            } catch (Exception e) {
                // TODO: handle exception
            } finally {
                res.lock.unlock();
            }
        }

    }
}

3.3 Lock与synchronized 比较

  1. 锁的实现：synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
  2. 性能：新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
  3. 等待可中断：当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。ReentrantLock 可中断，而 synchronized 不行。
  4. 公平锁，公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
  5. 锁绑定多个条件：一个 ReentrantLock 可以同时绑定多个 Condition 对象。
  6. 使用选择
    • 除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。

【Java并发】线程通信

标签：boolean   strong   handle   out   注意   机制   sleep   指定   读取   

原文地址：https://www.cnblogs.com/haoworld/p/java-bing-fa-xian-cheng-tong-xin.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！