等待和通知的标准范式

一。概念说明

1.等待和唤醒中的方法：
   wait：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，线程的状态即是waiting.
         它还要等别的线程执行唤醒动作，通知在这个对象上等待的线程从wait set中释放出来，重新进入调度内容
         
   notify：选取所通知对象的wait set中的一个线程释放，
   notifyAll：释放所通知对象wait set中所有线程释放

注意：哪怕只通知对象的一个线程释放，被通知线程也不能立即执行。
因为当初中断的地方是在同步块内，而此刻它已经不持有锁，所以需要重新获取锁（有可能面临其他线程），成功后才能执行当初wait方法后的代码

总结：如果能获取锁，线程状态就从waiting变成runnable
     如果不能获取锁，就从waiting变成blocking

2.调用wait和notify/notifyAll需要注意的地方
  a.必须要由同一个锁对象调用  因为对应的锁对象才可以通过notify唤醒使用同一个锁对象调用wait方法后面的代码
  b.wait方法和notify方法必须在同步代码块或者同步函数中使用

二。等待和通知的标准范式

要包含在synchronized里面，用锁对象进行等待和通知

wait方法一旦被调用，会立即释放线程所持有的锁(这样其他线程才能持这个锁去通知唤醒)
而nofify和notify调用不会立即释放线程持有的锁，会直到synchronized包含的代码块执行完成才释放

三。案例

一。netty连接

1.netty客户端如何没有连接上就进行等待

NettyClient nettyClient = new NettyClient();
new Thread(nettyClient).start();
while(!nettyClient.isConnected()){
    synchronized (nettyClient){
        nettyClient.wait();
    }
}
System.out.println("网络通信已准备好，可以进行业务操作了........");

2.netty客户端连接上就唤醒

Bootstrap b = new Bootstrap();
b.group(group).channel(NioSocketChannel.class)
        .option(ChannelOption.TCP_NODELAY, true)
        .handler(new ClientInit());
// 发起异步连接操作
ChannelFuture future = b.connect(new InetSocketAddress(host, port)).sync();
channel = future.sync().channel();
/*连接成功后通知等待线程，连接已经建立*/
synchronized (this) {
    this.connected = true;
    this.notifyAll();
}
future.channel().closeFuture().sync();

二。线程等待（出现在周瑜手写分布式事务）

1.定义一个task类，有等待和唤醒两个方法

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Task {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    /**
     * 等待任务
     */
    public void waitTask() {
        try {
            lock.lock();
            condition.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 唤醒任务
     */
    public void signalTask() {
        lock.lock();
        condition.signal();
        lock.unlock();
    }
}

2.等待

//3.执行目标对象方法并设置本地事务类型
try {
    final TransactionStatus transactionStatus = transactionUtil.begin();
    pjp.proceed();

    //等待：开启一个线程进行等待，等到唤醒才会执行watTaks下面的动作，但是线程意外的代码不用等唤醒就执行)
    new Thread(new Runnable() {
        @Override
        public void run() {
            //等待
            transactionDTO.getTask().waitTask();
            //下面这部分代码是会等唤醒才会执行
            if (TransactionTypeEnum.commit.value().equals(transactionDTO.getTransactionType())){
                transactionUtil.commit(transactionStatus);
            }
        }
    }).start();
} catch (Exception e) {
    localTransaction.setTransactionType(TransactionTypeEnum.rollback.value());
}

3.唤醒

//1.获取本地事务
LocalTransaction localTransaction = GlobalTransactionManager.getLocalTransactionByGroupId(transactionCommandRebackDTO.getGroupId());
//2.获取本地事务的task并唤醒
localTransaction.getTask().signalTask();

三。自己测试ok 锁对象localTransaction是spring容器的bean

@Component
@Data
public class LocalTransaction {
}

等待

public String testWait() {
   System.out.println("进入service1方法");

    //等待：开启一个线程进行等待，等到唤醒才会执行watTaks下面的动作，但是线程意外的代码不用等唤醒就执行)
    new Thread(new Runnable() {
        @SneakyThrows
        @Override
        public void run() {
            //等待
            synchronized (localTransaction){
                System.out.println("service1等待前");

                localTransaction.wait();
            }
            //下面这部分代码是会等唤醒才会执行
            System.out.println("service1等待后");
        }
    }).start();
    System.out.println("service1方法结束");
    return "进入service1方法";
}

唤醒

@Override
public String test2() {
    System.out.println("进入service2方法");

    //唤醒线程
    synchronized (localTransaction){
        System.out.println("test2唤醒线程前");
        localTransaction.notifyAll();
        System.out.println("test2唤醒线程后");

        System.out.println("service2方法结束");
    }
    return "进入service2方法";
}