Java多线程：syschronized，lock优缺点及demo

lock相比syschronized，任何一个新的技术是对已有技术的优化和补充

同一时刻只允许有一个线程访问代码块的机制，是为了保证线程安全而生(存储数据的集合数据安全)。

创建锁的3种方式：继承Thread类，实现接口runable,callable

syschronized：队列，锁，通一时间只有一个队列消费
区别
1、synchronized是java关键字，而Lock是java中的一个接口
2、synchronized会自动释放锁，而Lock必须手动释放锁
3、synchronized是不可中断的，Lock可以中断也可以不中断
4、通过Lock可以知道线程有没有拿到锁，而synchronized不能
5、synchronized能锁住方法和代码块，而Lock只能锁住代码块
6、Lock可以使用读锁提高多线程读效率
7、synchronized是非公平锁，ReentranLock可以控制是否公平锁

1 lock()：获取锁，如果锁被暂用则一直等待
2 unlock():释放锁
3 tryLock(): 注意返回类型是boolean，如果获取锁的时候锁被占用就返回false，否则返回true
4 tryLock(long time, TimeUnit unit)：比起tryLock()就是给了一个时间期限，保证等待参数时间
5 lockInterruptibly()：用该锁的获得方式，如果线程在获取锁的阶段进入了等待，那么可以中断此线程，先去做别的事

-----demo---------
package com.chen.thread;

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

/**

• 使用场景：生产线：下单完成唤醒执行支付--》支付成功唤醒交易-->交易成功唤醒 物流

• 按顺序执行的场景
  */
  public class LcckTest1 {
  public static void main(String[] args) {
  Data3 data3=new Data3();
  new Thread(()->{
  for (int i = 0; i < 10; i++) {
  data3.PrintA();
  }
  },"A").start();

  new Thread(()->{
  for (int i = 0; i < 10; i++) {
  data3.PrintB();
  }
  },"B").start();

  new Thread(()->{
  for (int i = 0; i < 10; i++) {
  data3.PrintC();
  }
  },"C").start();
  }

}

class Data3 {
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();

private int numer = 1;

public void PrintA() {
lock.lock();
try {
while (numer != 1) {
condition1.await();
}
System.out.println(Thread.currentThread().getName() + "==>A");
numer = 2;
condition2.signal(); //执行完成唤醒2
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}

public void PrintB() {
lock.lock();
try {
while (numer != 2) {
condition2.await();
}
System.out.println(Thread.currentThread().getName() + "==>B");
numer = 3;
condition3.signal(); //执行完成唤醒3
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}

public void PrintC() {
lock.lock();
try {
while (numer != 3) {
condition3.await();
}
System.out.println(Thread.currentThread().getName() + "==>C");
numer = 1;
condition1.signal(); //执行完成唤醒1
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}

结果按顺序输出:
A>A
B>B
C>C
A>A
B>B
C>C
A>A
B>B
C>C
A>A
B>B
C>C
A>A
B>B
C>C
A>A
B>B
C>C
A>A
B>B
C>C
A>A
B>B
C>C
A>A
B>B
C>C
A>A
B>B
C>C