Java并发面试算法题目

这篇具有很好参考价值的文章主要介绍了Java并发面试算法题目。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

实现一个生产者,消费者

思路:用lock锁。定义一个类成员变量 max_value,min_value代表资源的最大,最小数量。

package org.app.common;

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

public class Resource {
        private int MAX_VALUE= 3;  
        private  int MIN_VALUE=0;
        private   int number = 0;
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
        public void consume(){
            try {
                lock.lock();
                while(number <= MIN_VALUE){
                    condition.await();
                }
                number--;
                System.out.println("【消费者】:消费了一个产品,【现仓储量为】:" + number);
                condition.signalAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
        public void produce(){
            try {
                lock.lock();
                while (number >MAX_VALUE) {
                    condition.await();
                }
                number++;
                System.out.println("【生产者】:生产了一个产品\t【现仓储量为】:" + number);
                condition.signalAll();
            }catch (Exception e){

            }finally {
                lock.unlock();
            }
        }
    public static void main(String[] args) {
        Resource resouce = new Resource();
        new Thread(()->{
            for(int i=0;i<10;i++){
                resouce.produce();
            }
        }).start();//生产者
        //消费者
        new Thread(()->{
            for (int i=1;i<=5;i++){
                resouce.consume();
            }
        },String.valueOf("消费者")).start();
    }
}

线程交替打印问题

2个线程交替打印1-10

问题解决方法比较多。文章来源地址https://www.toymoban.com/news/detail-836386.html


private static volatile int num = 1;
private static Object lock = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread() {
            public void run() {
                while (num < 99) {
                    if (num % 2 == 0) {
                        synchronized (lock) {
                            lock.notify();
                            System.out.println("t1" + "_" + num);
                            num++;
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                }
            }
        };
        Thread t2 = new Thread() {
            public void run() {
                while (num < 99) {
                    if (num % 2 == 1) {
                        synchronized (lock) {
                            lock.notify();
                            System.out.println("t2" + "_" + num);
                            num++;
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                }
            }
        };
        t1.start();
        t2.start();

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

public class Main2 {
    private int time;
    private int state;
    private Lock lock = new ReentrantLock();
    public Main2(int time){
        this.time = time;
    }
    public void print(String name,int targetNum){
        for(int i=0;i<time;){
            lock.lock();
            if (state % 3 == targetNum) {
                state++;
                i++;
                System.out.println(name);
            }
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Main2 main2 = new Main2(2);
        new Thread(()->{
            main2.print("B", 1);
        },"B").start();      new Thread(()->{
            main2.print("C", 2);
        },"C").start();
        new Thread(()->{
            main2.print("A", 0);
        },"A").start();
    }
}

到了这里,关于Java并发面试算法题目的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 01.java并发编程面试宝典

    谈谈什么是线程池 线程池和数据库连接池非常类似,可以统一管理和维护线程,减少没有必要的开销。 因为频繁的开启线程或者停止线程,线程需要从新被 cpu 从就绪到运行状态调度,需要发生上下文切换 实际开发项目中 禁止自己 new 线程。必须使用线程池来维护和创建线

    2024年02月03日
    浏览(106)
  • Java并发编程面试题——线程池

    参考文章: 《Java 并发编程的艺术》 7000 字 + 24 张图带你彻底弄懂线程池 (1) 线程池 (ThreadPool) 是一种用于 管理和复用线程的机制 ,它是在程序启动时就预先创建一定数量的线程,将这些线程放入一个池中,并对它们进行有效的管理和复用,从而在需要执行任务时,可以从

    2024年02月07日
    浏览(51)
  • 一文吃透Java并发高频面试题

    内容摘自我的学习网站:topjavaer.cn 分享50道Java并发高频面试题 。 线程池:一个管理线程的池子。 嗯,手动创建线程有两个缺点 不受控风险 频繁创建开销大 为什么不受控 ? 系统资源有限,每个人针对不同业务都可以手动创建线程,并且创建线程没有统一标准,比如创建的

    2024年02月07日
    浏览(61)
  • 面试最常被问的 Java 后端题目及参考答案

    一、Java 基础篇 1. Object 有哪些常用方法?大致说一下每个方法的含义 2. Java 创建对象有几种方式? 3. 获取一个类对象的方式有哪些? 4. ArrayList 和 LinkedList 的区别有哪些? 5. 用过 ArrayList 吗?说一下它有什么特点? 6. 有数组了为什么还要搞个 ArrayList 呢? 7. 说说什么是 fai

    2024年02月12日
    浏览(44)
  • Java面试_并发编程_线程基础

    进程是正在运行程序的实例, 进程中包含了线程, 每个线程执行不同的任务 不同的进程使用不同的内存空间, 在当前进程下的所有线程可以共享内存空间 线程更轻量, 线程上下文切换成本一般上要比进程上下文切换低(上下文切换指的是从一个线程切换到另一个线程) 并发是单个

    2024年02月07日
    浏览(53)
  • Java -并发(多线程)-Interview面试题收集

      1)多线程中 synchronized 锁升级的原理是什么? synchronized 锁升级原理:在锁对象的对象头里面有一个 threadid 字段,在第一次访问的时候 threadid 为空,jvm 让其持有偏向锁,并将 threadid 设置为其线程 id,再次进入的时候会先判断 threadid 是否与其线程 id 一致,如果一致则可以

    2024年02月06日
    浏览(58)
  • 一天吃透Java并发面试八股文

    内容摘自我的学习网站:topjavaer.cn 分享50道Java并发高频面试题 。 线程池:一个管理线程的池子。 嗯,手动创建线程有两个缺点 不受控风险 频繁创建开销大 为什么不受控 ? 系统资源有限,每个人针对不同业务都可以手动创建线程,并且创建线程没有统一标准,比如创建的

    2024年02月08日
    浏览(53)
  • 第二章--Java多线程高并发+面试题

    s1 基础知识 001 并发编程的优缺点 优点 充分利用多核cpu的计算能力 方便业务拆分,提升系统并发能力和性能,提升程序执行效率,提速 缺点 内存泄漏 | 上下文切换 线程安全 | 死锁 002 并发编程三要素 三要素 安全问题的原因 具体原因 对策 原子性 线程切换 一个或多个操作要么

    2024年02月06日
    浏览(64)
  • 互联网Java工程师面试题·Java 并发编程篇·第五弹

    目录 52、什么是线程池? 为什么要使用它? 53、怎么检测一个线程是否拥有锁? 54、你如何在 Java 中获取线程堆栈? 55、JVM 中哪个参数是用来控制线程的栈堆栈小的? 56、Thread 类中的 yield 方法有什么作用? 57、Java 中 ConcurrentHashMap 的并发度是什么? 58、Java 中 Semaphore 是什么

    2024年02月07日
    浏览(67)
  • 2023Java高频必背并发编程面试题02

    CAS 算法是 基于值来做⽐较的 ,如果当前有两个线程,⼀个线程将变量值从 A 改为 B ,再由 B 改回为 A,当前线程开始执⾏ CAS 算法时,就很容易认为值没有变化,误认为读取数据到执⾏ CAS 算法的期间,没有线程修改过数据。 juc 包提供了⼀个 AtomicStampedReference,即 在原始的

    2023年04月09日
    浏览(62)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包