一. 请你谈一谈synchronized和lock有什么区别?
1.synchronized是java的关键字,属于jvm层面,底层是通过moninter对象实现的.Lock是具体的接口,属于api层面.
2.synchronized不需要用户去手动释放锁,当synchronized的代码执行完成后,系统会自动释放线程对锁的占用,Lock
则需要用户去手动释放锁,如果没有主动去释放锁,就会导致死锁的发生.
3.synchronized不可被中断,除非程序执行完毕或抛出异常.Lock可以被中断(1.设置超时方法 tryLock() 2.lockInterruptibly()
放代码块中,调用interrupt()可中断)
4.synchronized是非公平锁,Lock默认也是非公平锁,但可以通过构造方法,传入布尔值来确定锁的类型.(true 公平锁,false 非公平锁)
5.synchronized没有绑定多个条件,Lock可以分组唤醒需要唤醒的线程,实现精确唤醒,而不像synchronized那样随机唤醒一个线程
要么全部唤醒.
案例:实现多线程之间的精确调用(实现A->B->C三个线程之间的启动),
lock优于synchronized的举例
要求:A线程打印5次,B线程打印10次,C线程打印15次,紧接着A在打印5次
B打印10次,C打印15次.循环执行10次
class ShareResource{
private int num = 1; // 标志位 1表示A线程执行,2表示B线程执行,3表示C线程执行
private Lock lock = new ReentrantLock();
private Condition c1 = lock.newCondition(); // A线程执行条件
private Condition c2 = lock.newCondition(); // B线程执行条件
private Condition c3 = lock.newCondition(); // C线程执行条件
public void print5(){
lock.lock();
try {
//如果不是A线程执行
while (num != 1){
//A线程等待
c1.await();
}
// 切换到B线程
num = 2;
// 唤醒B线程
c2.signal();
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() + "\t"+i);
}
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void print10(){
lock.lock();
try {
while (num != 2){
c2.await();
}
num = 3;
c3.signal();
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + "\t"+i);
}
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void print15(){
lock.lock();
try {
while (num != 3){
c3.await();
}
num = 1;
c1.signal();
for (int i = 1; i <= 15; i++) {
System.out.println(Thread.currentThread().getName() + "\t"+i);
}
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
ShareResource sr = new ShareResource(); //获取对象
// 执行10次A线程
new Thread(()->{
for (int i = 1; i <= 10; i++) {
sr.print5();
}
},"A").start();
// 执行10次B线程
new Thread(()->{
for (int i = 1; i <= 10; i++) {
sr.print10();
}
},"B").start();
// 执行10次C线程
new Thread(()->{
for (int i = 1; i <= 10; i++) {
sr.print15();
}
},"C").start();
}
执行结果:
A,B,C三个线程依次执行,没有插队的情况,结果就是正确的
二 . 请你谈一谈生产者/消费者模型,并结合业务,写一个案例
举例:多个线程同时操作一份数据,生产者+1,消费者-1
1.使用Lock实现
class ShareData{
private int number = 0; // 资源数据
private Lock lock = new ReentrantLock(); // 锁对象
private Condition condition = lock.newCondition(); // 条件
/*生产者 +1操作*/
public void increment(){
lock.lock();
try {
// 如果生产者已经满了,就进入等待状态
// 要使用while防止虚假唤醒(jdk1.8文档源码,不能使用if !!!)
while (number != 0){
// 等待
condition.await();
}
// 业务逻辑 +1
number++;
System.out.println(Thread.currentThread().getName() + "\t"+number);
//唤醒消费者线程进行-1
condition.signalAll();
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
/*消费者线程 -1操作*/
public void decrement(){
lock.lock();
try {
// 如果已经没有资源了,number = 0 ,等待生产者线程生产
while (number == 0){
condition.await();
}
// 业务逻辑 -1
number--;
System.out.println(Thread.currentThread().getName() + "\t"+number);
// 唤醒生产者线程
condition.signalAll();
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
ShareData shareData = new ShareData();
// 生产者
new Thread(()->{
for (int i = 1; i <= 5; i++) {
shareData.increment();
}
},"T1").start();
//消费者
new Thread(()->{
for (int i = 1; i <= 5; i++) {
shareData.decrement();
}
},"T2").start();
}
执行结果:
生产一个,消费一个,生成一个,消费一个 .......
2. 使用BlockingQueue实现
class ShareMessage{
// 开关,true表示执行,false表示关闭
private volatile boolean FLAG = true;
// 原子整型,操作不能被分割
private AtomicInteger atomicInteger = new AtomicInteger();
// 阻塞队列,用于存放数据
private BlockingQueue<String> blockingQueue = null;
// 初始化BlockingQueue 对象的具体的实现类
public ShareMessage(BlockingQueue<String> blockingQueue) {
this.blockingQueue = blockingQueue;
System.out.println(blockingQueue.getClass().getName());
}
/*生产者模型,*/
public void produce() throws InterruptedException{
String data = null;
boolean retValue ;
while (FLAG){ // 如果开关打开
// 等同于 i++ + ""
data = atomicInteger.incrementAndGet() + "";
// 把数据放到阻塞队列中,并设置超时的时间
retValue = blockingQueue.offer(data,2L, TimeUnit.SECONDS);
// 如果放置成功
if(retValue){
System.out.println(Thread.currentThread().getName() + "\t"+ data + "插入队列成功");
}else {
System.out.println(Thread.currentThread().getName() + "\t"+ data + "插入队列失败");
}
// 让消费者线程取,方便显示
TimeUnit.SECONDS.sleep(1);
}
System.out.println(Thread.currentThread().getName() + "生产结束,FLAG设置为false");
}
/*消费者线程*/
public void consume() throws InterruptedException{
String res = null;
while (FLAG){
// 从阻塞队列中获取数据
res = blockingQueue.poll(2L,TimeUnit.SECONDS);
// 如果没有获取到数据,
if(null == res || res.equalsIgnoreCase("")){
// 停止生产者线程,并退出当前的消费者线程
FLAG = false;
System.out.println(Thread.currentThread().getName()+"\t超过2秒钟没有取到数据,消费退出");
return;
}
System.out.println(Thread.currentThread().getName()+"\t"+res+"消费队列成功");
}
}
/*关闭生产/消费模型*/
public void stop(){
this.FLAG = false;
}
}
public static void main(String[] args) {
ShareMessage sm = new ShareMessage(new ArrayBlockingQueue<>(10));
// 启动生产者
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"生产线程启动");
try {
sm.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"produce").start();
// 启动消费者
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"消费线程启动");
try {
sm.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"consume").start();
// 执行5秒钟后,停止运行
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
sm.stop();
}
执行结果:
j结论:
使用阻塞队列实现生产者/消费者模型更优于使用Lock的方式,因为阻塞队列中不需要手动的去停止/唤醒线程.
原文地址：https://www.cnblogs.com/luhuajun/p/12130819.html
时间： 2024-10-05 16:19:24