Java并发线程通信

Posted 爱吃兔肉的保尔

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java并发线程通信相关的知识,希望对你有一定的参考价值。

一、概述

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并发线程通信的主要内容,如果未能解决你的问题,请参考以下文章

Java并发编程之线程安全线程通信

Java多线程与并发库4.传统线程同步通信技术

Java并发线程通信

Java多线程与并发库4.传统线程同步通信技术

转:Java并发编程之十二:线程间通信中notifyAll造成的早期通知问题(含代码)

转:Java并发编程之十一:线程间通信中notify通知的遗漏(含代码)