面试重点 java并发编程

最新推荐文章于 2024-01-16 11:51:33 发布
最新推荐文章于 2024-01-16 11:51:33 发布
阅读量103 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37437892/article/details/119270042
版权

面试重点 java并发编程

lock接口

在这里插入图片描述
ReentrantLock最常用
在这里插入图片描述

在这里插入图片描述
假如有一个执行时间为2h、2s顺序排列的线程，可以插队的话，就不至于让2s的线程等太久

package com.MulThread;

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

public class LockPractice {
    public static void main(String[] args) {
    Ticket1 t = new Ticket1();

    new Thread(()->{
        for (int i = 0; i < 30; i++) {
            t.saleTicket();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    },"A").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                t.saleTicket();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                t.saleTicket();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();


    }
}

//如果implements runnable 接口的话 耦合性会强
//使用函数式接口（一个接口仅有一个抽象函数）
class Ticket1{
    private  int num=50;
    public  void saleTicket(){
        Lock l = new ReentrantLock();//

        l.lock();//加锁
        try {
//业务代码
            if (num>0)
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(num--)+"张票，还剩"+num+"张票！");

        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            l.unlock();
        }
    }
}

以上相当于手动挡，自动挡如下

package com.MulThread;

public class ThreadPractice {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(
          ()-> {
              for (int i = 0; i < 30; i++) {
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  t.saleTicket();
              }

          },"A"
        ).start();
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < 30; i++) {
                            try {
                                Thread.sleep(100);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            t.saleTicket();
                        }
                    }
                },"B"
        ).start();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                t.saleTicket();
            }

        },"C").start();

    }
}


//如果implements runnable 接口的话 耦合性会强
//使用函数式接口（一个接口仅有一个抽象函数）
class Ticket{
    private static int num=50;
    public synchronized   void saleTicket(){
        if (num>0)
        System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票，还剩"+num+"张票！");
    }
}

synchronized和lock的区别

1.synchronized是java关键字，lock是java一个类（接口）；
2.synchronized是可重入锁，不可以中断，非公平锁；lock是可重入锁，可以判断锁，非公平锁（可变）；
3.（自动挡和手动挡的区别）synchronized会自动释放锁，而lock需要手动释放，否则会产生死锁；
4.synchronized无法判断获取锁的状态，lock可判断是否获取到了锁；
5.synchronized适合锁少量的代码同步问题；而lock适合锁大量的代码同步问题
6.在使用synchronized锁时，线程1获得锁，线程3就会傻等，而lock锁不一定会等待下去

生产者和消费者问题

synchronized版本

package com.ShengChanXiaoFei;

public class ConsumerPra {
    public static void main(String[] args) {


        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();



        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}



// 判断等待 业务 通知  （口诀）
class Data{
    private int num=0;


//    生产操作
    public synchronized void increment() throws InterruptedException {
        while(num!=0){
//            等待
            System.out.println(Thread.currentThread().getName()+"在等");
            this.wait();
        }
        num++;
//        业务
        System.out.println(Thread.currentThread().getName()+"===>"+num);
        this.notifyAll();
//        通知其它小伙伴来运行
    }


//    消费操作

    public synchronized void decrement() throws InterruptedException {
        while(num==0){
//           因为没有产品可以消费了 等待
            System.out.println(Thread.currentThread().getName()+"在等");
            this.wait();
        }
//        业务
        num--;
        System.out.println(Thread.currentThread().getName()+"==>"+num);

//        通知
        this.notifyAll();
    }
}

判断的地方如何把while改为if的话 问题A、B两个线程是安全的。但A、B、C、D四个线程时不安全
if只判断1次会存在虚假唤醒的问题

在这里插入图片描述

JUC版本的生产者和消费问题

在这里插入图片描述

package com.ShengChanXiaoFei;

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

public class LockPra {

    public static void main(String[] args) {
        Data1 d = new Data1();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {

                    d.increment();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    d.decrement();
                    Thread.sleep(1000);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    d.increment();
                    Thread.sleep(1000);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();



        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    d.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();




    }
}

// 判断等待 业务 通知  （口诀）
class Data1{
    private static int num=0;

    Lock lock = new ReentrantLock();

    Condition conditionA = lock.newCondition();



    //    生产操作
    public    void increment() throws InterruptedException {
      lock.lock();
        try{
//            业务代码
            while(num!=0){
//            等待
//                System.out.println(Thread.currentThread().getName()+"在等");
//            this.wait();
                conditionA.await();
            }
            num++;
//        业务
            System.out.println(Thread.currentThread().getName()+"===>"+num);
//        this.notifyAll();
//        通知其它小伙伴来运行
            conditionA.signalAll();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }


//    消费操作

    public      void decrement() throws InterruptedException {

        lock.lock();


        try {
            while(num==0){
    //           因为没有产品可以消费了 等待
//                System.out.println(Thread.currentThread().getName()+"在等");
    //            this.wait();
                conditionA.await();
            }

//        业务
            num--;
            System.out.println(Thread.currentThread().getName()+"==>"+num);

//        通知
//        this.notifyAll();
            conditionA.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

使用lock精准控制 A执行了通知B、 B执行了通知C、C执行了通知A

package com.ShengChanXiaoFei;

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

public class LockLiuShui {

    public static void main(String[] args) {

        Data3 d = new Data3();


        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                try {
                    d.printC();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }).start();


        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                try {
                    d.printA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                try {
                    d.printB();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }
}
//  A执行完唤醒B B执行完唤醒C C执行完唤醒A
class Data3{
    private int number = 1;
//资源类  lock
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC= lock.newCondition();


    public void printA() throws InterruptedException {

        lock.lock();
        try {
            while (number!=1){
    //            等待
                conditionA.await();
            }
            number=2;
            System.out.println(Thread.currentThread().getName()+"==>"+number+"AAAAAAA");

//        业务
            conditionB.signal();
//        通知
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void printB() throws InterruptedException {
        lock.lock();
        try {
            while(number!=2){
    //            等待
                conditionB.await();
            }
//        业务
            number=3;
            System.out.println(Thread.currentThread().getName()+"==>"+number+"B");

            conditionC.signal();
//        通知c
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void printC() throws InterruptedException {

        lock.lock();
        try {
            while (number!=3){
    //            等待
                conditionC.await();
            }
//        业务
            number=1;
            System.out.println(Thread.currentThread().getName()+"==>"+number+"C");


//        通知
            conditionA.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }


}

在这里插入图片描述

爱学习的羽
关注
专栏目录
java并发编程面试题
用文字记录下每一个瞬间的感动和每一次思考的火花
09-28 9万+
文章目录1、Synchronized用过吗，其原理是什么？2、你刚才提到获取对象的锁，这个“锁”到底是什么？如何确定对象的 锁？3、什么是可重入性，为什么说Synchronized是可重入锁？4、JVM对Java的原生锁做了哪些优化？5、为什么说Synchronized是非公平锁？6、什么是锁消除和锁粗化？7、为什么说Synchronized是一个悲观锁?乐观锁的实现原理又是什么？什么是CAS,它有什么特性？8、乐观锁一定就是好的吗？9、跟Synchronized相比，可重入锁ReentrantLock其实
Java并发编程面试题（2021最新版）
xmt1139057136的专栏
09-04 1109
原文链接: https://thinkwon.blog.csdn.net/article/details/104863992 文章目录 Java 面试总结汇总，整理了包括Java基础知识，集合容器，并发编程，JVM，常用开源框架 Spring，MyBatis，数据库，中间件等，包含了作为一个 Java 工程师在面试中需要用到或者可能用到的绝大部分知识。欢迎大家阅读，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。本专栏持续更新中 … 基础知识 并发编程的优缺点 为什么.
黑马程序员----Java多线程
sven556677的博客
08-23 343
------- android培训、java培训、期待与您交流！ ---------- 1.概念： 进程：进行中的程序 线程：进程中不同的进行流程（执行路径） 多线程的好处：解决了多部分代码同时运行的问题。 弊端：CPU的切换会导致效率变低。 2.创建线程的两种方式 1）implements Runnable ：实现接口，避免了单继承造成的局限性 2）Exten
Java并发编程常见面试题
故不积跬步无以至千里
09-22 1466
普通方法对应于对象锁，是作用于对象实例；静态方法对应于类锁，是作用于一个类的class对象；类的对象实例可以有多个，但类的class对象只有一个；不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁；类锁只是一个概念的东西，真实并不存在，类锁其实锁的是每个类的class对象；可见性是值：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。根据java内存模型可知，多线程操作中存在可见性问题，可以通过volatile关键字或者加锁解决。
Java并发编程面试题（2022最新版）
weixin_45985053的博客
07-25 1467
多线程多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务。多线程编程中一般线程的个数都大于CPU核心的个数，而一个CPU核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是任务从保存到再加载的过程就是一次上下文切换。上下文切换通常是计算密集型的。互斥条件AtomicLong。......
【2022最新Java面试宝典】—— Java并发编程面试题（123道含答案）
记录各种Bug解决案例及日常学习内容
05-03 1万+
目录一、基础知识1. 为什么要使用并发编程2. 多线程应用场景3. 并发编程有什么缺点4. 并发编程三个必要因素是什么？5. Java 程序中怎么保证多线程的运行安全？6. 并行和并发有什么区别？7. 什么是多线程8. 多线程的好处9. 多线程的劣势：10. 线程和进程区别11. 什么是上下文切换?12. 守护线程和用户线程有什么区别呢？13. 如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？14. 什么是线程死锁15. 形成死锁的四个必要条件是什么16. 如何避免线程死锁17. 创
【Java面试】并发编程实战（线程控制操作详解）
陈橘又青的博客
07-01 1万+
在使用Java实际编程中，多线程可以说是无所不在，凡是需要并发执行的都可以用到它，一个应用程序中不用多线程将会是很糟糕的事情，所以掌握线程以及它的控制操作是非常重要的。今天带大家一文掌握 线程 。..........................................
java面试题（并发）
Java小菜鸟
03-19 1824
java多线程、java spring 、spring mvc、 spring boot面试题
【Java并发面试】10道不得不会的Java并发基础面试题
JavaPub
12-26 4073
1. start()方法和run()方法的区别 2. volatile关键字的作用 3. sleep方法和wait方法有什么区别 4. 如何停止一个正在运行的线程？ 5. java如何实现多线程之间的通讯和协作？(如何在两个线程间共享数据？) 6. 什么是ThreadLocal? 7. Java中CyclicBarrier 和 CountDownLatch有什么不同？ 8. 如何避免死锁？ 9. Java中synchronized 和 ReentrantLock 有什么不同？ 10. 有三个线程T1，T2，
关于并发的最常见的十道面试题
热门推荐
loss_rose777的博客
01-16 4万+
关于并发编程的十到面试题有详细的解答答案和例子让你更好的理解此题的原理，看一下自己会就几道题
Java并发编程面试题八股文
最新发布
01-30
Java并发编程面试题八股文，包括并发编程基本概念、锁、并发工具类、线程池等基本概念和高级用法。同时也介绍了上述知识点在面试过程中常见的问题及答案。 本材料适用于接下来要参加Java开发工程师岗位的面试同学，...
Java高并发编程，构建并发编程知识体系，提升面试成功率
09-23
Java高并发编程，构建并发编程知识体系，提升面试成功率，完整版17章视频教程下载。 本课程将结合大量图示及代码演示，带你掌握多线程并发编程（线程安全，线程调度，线程封闭，同步容器等）与高并发处理思路与手段...
Java并发编程面试题目
07-01
" Java并发编程面试题目" Java并发编程是Java编程语言中的一种核心技术，旨在提高程序的执行效率和响应速度。并发编程的优点是可以提高程序的执行效率，提高用户体验和系统性能。但是， 并发编程也存在一些缺点，...
大厂学院高阶班java并发编程面试视频资料(6.95G)
04-11
大厂学院高阶班java并发编程面试视频资料(6.95G) 〖课程介绍〗: 大厂学院高阶班java并发编程面试视频资料(6.95G) 〖课程目录〗: 01_前言.mp4 44.96M 02_线程的start方法.mp4 68.78M 03_进程线程管程.mp4 54.58M ...
Java并发编程面试题
09-30
Java并发编程面试题 Java并发编程是指在Java程序中同时执行多个线程以提高程序的执行效率和响应速度的技术。并发编程可以带来许多优点，如提高程序的执行效率、改善用户体验等。但同时，Java并发编程也存在一些缺点...
八皇后 java实现
秀
05-20 2516
回朔法： import java.util.Scanner; public class Main{ public static final int N=100; public static int []queen=new int[N]; public static int n; public static int sum=0; public static void main(Stri...
如何4招解决队列中的线程同步、阻塞问题
秀
08-03 1246
读写锁应用背景 package com.unsafe; import java.util.HashMap; import java.util.Map; public class ReadWriteLockPro { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 1; i <= 6; i++) { final
模拟购物车 java程序
秀
04-21 1191
package pra; import java.awt.Choice; import java.awt.Color; import java.awt.Component; import java.awt.Dimension; import java.awt.FlowLayout; import java.awt.Font; import java.awt.Graphics; import ja...
最大子段和 java
秀
05-20 475
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main{ public static void main(String args[]) throws NumberFormatException, IOException { ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值