多线程-4

最新推荐文章于 2024-03-17 21:20:55 发布

oh_mygarden

最新推荐文章于 2024-03-17 21:20:55 发布

阅读量157

点赞数

分类专栏： Java学习日志

本文链接：https://blog.csdn.net/oh_mygarden/article/details/53648633

版权

Java学习日志专栏收录该内容

8 篇文章 0 订阅

订阅专栏

# 线程通信
当一个程序中有多条并发线程执行时，线程之间是互不干扰的。程序通常无法准确的控制线程的轮换执行
在有些时候，我们需要在线程之间进行通信，要让两条线程按某种交替执行。
一条线程存钱进入，另一条线程立即去把钱取出来–这就需要用线程通信。
经典问题：（生产者–消费者）问题
解决思路是：
1. 首先设置一个旗标。
2. 当生产者线程试图生产时，它首先要判断旗标。
如果旗标代表已经生产过了，当前线程应该暂停下来。
如果旗标代表还没有生产，应该执行生产。

Object提供了如下方法：

wait（） -让当前正在执行的线程“等待”下来，进入阻塞状态。调用wait（）方法的当前线程会释放对该同步监视器的锁定。
notify（） -唤醒处于等待的线程，让它进入就绪状态。
notifyAll（） -唤醒所有处于等待的线程，让他们进入就绪状态。

上面这三个方法，表面上属于Object类，看上去任何对象都可以调用。但实际上，只有同步监视器才能调用。

如果不加控制，多个线程“自由”地并发执行。
可以通过同步，来解决多个线程并发访问竞争资源的问题。线程安全，必然带来性能的降低（Vector，Hashtable）

Java倡议为很多类提供两个版本
* ++线程安全的版本：适合多线程访问。 StringBuffer++
* ++线程不安全的版本：适合单线程环境。StringBuilder++

程序实例

==传统的线程通信==

假设现在系统中有两个线程，分别代表存款者和取钱者，现在要求两个线程重复轮流执行，也就是先存钱，再取钱，存钱–取钱–存钱–取钱。。。重复执行，每次存款者一存钱完毕，取钱者立马取钱，不允许存款后又存款。
++程序可以通过一个旗标来标识账户中是否已有存款，当旗标为FALSE时，表明账户中还没有存款，存款者线程可以向下执行，当把钱存入后，将旗标设为TRUE，并调用notifyAll（）方法来唤醒其他线程；当存款者线程进入线程体后，如果旗标为TRUE，就调用wait（）方法让该线程等待。这时取钱者线程可以向下执行，当取钱者执行完从账户中取完钱后，再将旗标设为FALSE，并调用notifyAll（）方法来唤醒其他线程；当取钱者线程进入线程体后，旗标为FALSE，就代表此时账户没有存款，就调用wait（）方法让取钱线程进入等待状态，让存款线程先去存钱。++

创建一个AccountS类，并提供draw（）和deposit（）两个方法，分别对应账户的取钱、存钱操作，因为这两个方法可能需要并发修改AccountS类的balance成员变量值，所以这两个方法都使用synchronized关键字修饰成同步方法。

public class AccountS

{

// 封装账户编号、账户余额的两个成员变量

private String accountNo;
private double balance;
// 标识账户中是否已有存款的旗标

private boolean flag = false;

public AccountS(){}
// 构造器
public AccountS(String accountNo , double balance)
{
    this.accountNo = accountNo;
    this.balance = balance;
}

// accountNo的setter和getter方法
public void setAccountNo(String accountNo)
{
    this.accountNo = accountNo;
}
public String getAccountNo()
{
    return this.accountNo;
}
// 因此账户余额不允许随便修改，所以只为balance提供getter方法，
public double getBalance()
{
    return this.balance;
}

public synchronized void draw(double drawAmount)
{
    try
    {
        // 如果flag为假，表明账户中还没有人存钱进去，取钱方法阻塞
        if (!flag)
        {
            wait();
        }
        else
        {
            // 执行取钱
            System.out.println(Thread.currentThread().getName()
                    + " 取钱:" +  drawAmount);
            balance -= drawAmount;
            System.out.println("账户余额为：" + balance);
            // 将标识账户是否已有存款的旗标设为false。
            flag = false;
            // 唤醒其他线程
            notifyAll();
        }
    }
    catch (InterruptedException ex)
    {
        ex.printStackTrace();
    }
}
public synchronized void deposit(double depositAmount)
{
    try
    {
        // 如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞
        if (flag)             //①
        {
            wait();
        }
        else
        {
            // 执行存款
            System.out.println(Thread.currentThread().getName()
                    + " 存款:" +  depositAmount);
            balance += depositAmount;
            System.out.println("账户余额为：" + balance);
            // 将表示账户是否已有存款的旗标设为true
            flag = true;
            // 唤醒其他线程
            notifyAll();
        }
    }
    catch (InterruptedException ex)
    {
        ex.printStackTrace();
    }
}

// 下面两个方法根据accountNo来重写hashCode()和equals()方法
public int hashCode()
{
    return accountNo.hashCode();
}
public boolean equals(Object obj)
{
    if(this == obj)
        return true;
    if (obj !=null
            && obj.getClass() == Account.class)
    {
        Account target = (Account)obj;
        return target.getAccountNo().equals(accountNo);
    }
    return false;
}

public class DrawThreadS extends Thread {

// 模拟用户账户
private AccountS account;
// 当前取钱线程所希望取的钱数
private double drawAmount;

public DrawThreadS(String name, AccountS account
        , double drawAmount) {
    super(name);
    this.account = account;
    this.drawAmount = drawAmount;
}

// 重复100次执行取钱操作
public void run() {
    for (int i = 0; i < 100; i++) {
        account.draw(drawAmount);
    }
 }
}

public class DepositThread extends Thread
{
// 模拟用户账户
private AccountS account;
// 当前取钱线程所希望存款的钱数
private double depositAmount;
public DepositThread(String name , AccountS account
        , double depositAmount)
{
    super(name);
    this.account = account;
    this.depositAmount = depositAmount;
}
// 重复100次执行存款操作
public void run()
{
    for (int i = 0 ; i < 100 ; i++ )
    {
        account.deposit(depositAmount);
     }
    }
}

public class DrawTestS
{
public static void main(String[] args)
 {
    // 创建一个账户
    AccountS accts = new AccountS("1234567" , 0);
    new DrawThreadS("取钱者" , accts , 800).start();
    new DepositThread("存款者甲" , accts , 800).start();
    new DepositThread("存款者乙" , accts , 800).start();
    new DepositThread("存款者丙" , accts , 800).start();
 }
}

关于为什么要在账户Account类末尾重写hashcode（）和equals（）方法，因为通常情况下，我们需要创建很多个账户，这些账户一般就需要用到HashSet来存储，而在往HashSet集合中添加元素时，就会根据hashcode值来判断两个元素是否重复。所以需要重写hashcode方法，以及紧密相关的equals方法。

查看
重写hashcode（）和equals（）的具体作用

==总结：一般对于存放到Set集合或者Map中键值对的元素，需要按需要重写hashCode与equals方法，以保证唯一性！==

使用Condition控制线程通信

如果程序不使用synchronized关键字来保证同步，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用wait（）、notifyAll（）方法进行线程通信了。

当使用Lock对象来保证同步时，Java提供了一个Condition类来保持协调，使用Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象，Condition对象也可以唤醒其他处于等待的线程。

Condition 将同步监视锁方法（wait、notify 和notifyAll）分解成截然不同的对象，以便通过将这些对象与Lock对象组合使用，为每个对象提供多个等待集（wait-set）。

在这种情况下，Lock 替代了同步方法或同步代码块，Condition替代了同步监视锁的功能。
Condition实例实质上被绑定在一个Lock对象上。
要获得特定Lock实例的Condition实例，调用Lock对象的newCondition()方法即可。

Condtion类提供了如下三个方法：
* await()：类似于隐式同步监视器上的wait()方法，导致当前线程等待，直到其他线程调用该Condtion的signal ()方法或signalAll ()方法来唤醒该线程。该await方法有更多变体：long awaitNanos(long nanosTimeout)、void awaitUninterruptibly()、awaitUntil(Date deadline)等，可以完成更丰富的等待操作。
* signal ()：唤醒在此Lock对象上等待的单个线程。如果所有线程都在该Lock对象上等待，则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对该Lock对象的锁定后（使用await()方法），才可以执行被唤醒的线程。
* signalAll()：唤醒在此Lock对象上等待的所有线程。只有当前线程放弃对该该Lock对象的锁定后，才可以执行被唤醒的线程。

下面程序中Account使用Lock对象来控制同步，并使用Condition对象来控制线程的协调运行。

public class Account
{
// 显式定义Lock对象
private final Lock lock = new ReentrantLock();
// 获得指定Lock对象对应的Condition
private final Condition cond  = lock.newCondition();
// 封装账户编号、账户余额的两个成员变量
private String accountNo;
private double balance;
// 标识账户中是否已有存款的旗标
private boolean flag = false;

public Account(){}
// 构造器
public Account(String accountNo , double balance)
{
    this.accountNo = accountNo;
    this.balance = balance;
}

// accountNo的setter和getter方法
public void setAccountNo(String accountNo)
{
    this.accountNo = accountNo;
}
public String getAccountNo()
{
    return this.accountNo;
}
// 因此账户余额不允许随便修改，所以只为balance提供getter方法，
public double getBalance()
{
    return this.balance;
}

public void draw(double drawAmount)
{
    // 加锁
    lock.lock();
    try
    {
        // 如果flag为假，表明账户中还没有人存钱进去，取钱方法阻塞
        if (!flag)
        {
            cond.await();
        }
        else
        {
            // 执行取钱
            System.out.println(Thread.currentThread().getName()
                + " 取钱:" +  drawAmount);
            balance -= drawAmount;
            System.out.println("账户余额为：" + balance);
            // 将标识账户是否已有存款的旗标设为false。
            flag = false;
            // 唤醒其他线程
            cond.signalAll();
        }
    }
    catch (InterruptedException ex)
    {
        ex.printStackTrace();
    }
    // 使用finally块来释放锁
    finally
    {
        lock.unlock();
    }
}
public void deposit(double depositAmount)
{
    lock.lock();
    try
    {
        // 如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞
        if (flag)             // ①
        {
            cond.await();
        }
        else
        {
            // 执行存款
            System.out.println(Thread.currentThread().getName()
                + " 存款:" +  depositAmount);
            balance += depositAmount;
            System.out.println("账户余额为：" + balance);
            // 将表示账户是否已有存款的旗标设为true
            flag = true;
            // 唤醒其他线程
            cond.signalAll();
        }
    }
    catch (InterruptedException ex)
    {
        ex.printStackTrace();
    }
    // 使用finally块来释放锁
    finally
    {
        lock.unlock();
    }
}

// 下面两个方法根据accountNo来重写hashCode()和equals()方法
public int hashCode()
{
    return accountNo.hashCode();
}
public boolean equals(Object obj)
{
    if(this == obj)
        return true;
    if (obj !=null
        && obj.getClass() == Account.class)
    {
        Account target = (Account)obj;
        return target.getAccountNo().equals(accountNo);
    }
    return false;
    }
}

对比上一个程序，不难发现两个程序的逻辑基本相似，不同之处在于现在显示地使用Lock对象来充当同步监视器，需要使用Condition对象来暂唤醒指定线程。

## 使用阻塞队列（BlockingQueue）控制线程通信
详见书本P746

### 关于章节练习题
1. 首先，需要用一个数组装56个英文字母，可以这么写
java char[] zimu =new char[26]; for(int i=0;i<26;i++){ zimu[i]=(char) (i+65); } System.out.println(zimu);
用一个数组装1-52数字

 int[] number =new int[52];
    for(int i=0;i<52;i++){
        number[i]=i+1;
    }
    for(int n:number){
        System.out.println(n);

解题思路参考

oh_mygarden

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录