中间变量

比第一种好 出现不一致性概率小，方法完成前读到脏数据概率小

哲学家问题

死锁：两把锁 在锁定一把的时候等待另外一把锁
解决方案：

  • 两把锁合并成一把锁（锁的粗化）
  • 混进一个左撇子
  1. if (index ==0){
  2.     sync(right){
  3.         sync(left){
  4.         }
  5.     }
  6. }else{
  7.     sync(left){
  8.         sync(right){
  9.         }
  10.     }
  11. }
  • 效率更高的写法，奇数偶数分开，混进一半的左撇子（index%2==0）

交替输出问题

  1. Locksupport 交替执行park当前线程阻塞（停止）内部做的标记
  2. TransferQueue 容量为0的队列

  1. new Thread(()->{
  2.     synchronized(o){
  3.         for(char c:aI){
  4.             System.out.print(c);
  5.             try{
  6.                 o.notify();
  7.                 o.wait();//让出锁
  8.             }catch(InterruptedException e){
  9.                 e.printStackTrace();
  10.             }
  11.         }
  12.         o.notify();//必须，否则无法停止程序
  13.     }
  14. },"t1").start();
  16. new Thread(()->{
  17.     synchronized(o){//当成一把锁来使用 当前线程关联的等待队列
  18.         for(char c:aC){
  19.             System.out.print(c);
  20.             try{
  21.                 o.notify();
  22.                 o.wait();//让出锁
  23.             }catch(InterruptedException e){
  24.                 e.printStackTrace();
  25.             }
  26.         }
  27.         o.notify();//必须，否则无法停止程序
  28.     }
  29. },"t2").start();
  1. countDownLatch 先await
  2. Lock ReentrantLock await signal
    condition理解为一个队列lock.newCondition();

生产者消费者问题 ReentantLock Condition

  1. lock.lock();
  2. try{
  3.     while(count>=maxNum){
  4.     producerCondition.awati();
  5.     System.out.println("生产能力上限，等待")；
  6.     }
  7.     count++;
  8.     System.out.println(Thread.currentThread().getName()
  9.     +"生产者生产，目前有"+count);
  10.     //唤醒消费者
  11.     consumerCondition.signalAll();
  12. }catch(){}finally{
  13.     lock.unlock();
  14. }

异步回调回滚问题（分布式事务）

大任务分解成小任务，出错回滚问题（分布式事务）

管理器监听 自己callback回滚

底层同步问题（乱序和屏障的问题）

  • cpu存在乱序执行
    ALU CPU内部运算单元 访问寄存器的速度，比访问内存的速度快100倍
    DCL单例需不需要voliate 旧的需要 新的不需要已优化