Java多线程经典案例分享
案例一
实现一个容器，提供两个方法，add()，count() 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。
本案例我通过闭锁（也叫门栓锁）实现，实现如下：
package day_12_28.zuoye;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
/**
* @author soberw
* @Classname AddAndCount
* @Description 实现一个容器，提供两个方法，add，count 写两个线程，
* 线程1添加10个元素到容器中，线程2实现监控元素的个数，
* 当个数到5个时，线程2给出提示并结束。
* @Date 2021-12-28 10:45
*/
public class AddAndCount {
CountDownLatch cdl = new CountDownLatch(1);
List<String> list = new ArrayList<>();
public static void main(String[] args) {
var aac = new AddAndCount();
new Thread(aac::add, "A").start();
new Thread(aac::count, "B").start();
}
void add() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
String item = String.format("%s - %d", "item", i);
list.add(item);
System.out.println(Thread.currentThread().getName() + ":" + item);
if (i == 4) {
cdl.countDown();
}
}
}
void count() {
try {
cdl.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("程序结束...");
System.exit(0);
}
}
案例二
编写程序模拟死锁。
死锁，简单来说就是两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
下面我就模拟这一状态：
package day_12_28.zuoye;
/**
* @author soberw
* @Classname Deadlock
* @Description 编写程序模拟死锁
* @Date 2021-12-28 10:59
*/
public class Deadlock {
private final Object o1 = new Object();
private final Object o2 = new Object();
public static void main(String[] args) {
Deadlock d = new Deadlock();
new Thread(d::m1).start();
new Thread(d::m2).start();
}
void m1(){
System.out.println(Thread.currentThread().getName() + "启动等待...");
synchronized(o1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(o2){
System.out.println("哈哈..");
}
}
}
void m2(){
System.out.println(Thread.currentThread().getName() + "启动等待...");
synchronized(o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(o1){
System.out.println("哈哈..");
}
}
}
}
案例三
编写程序，实现三个线程，运行输出 A1 B2 C3 A4 B5 C6 ……
我这里用了两种方式去实现：
方式一：
用公平锁：
package day_12_28.zuoye;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author soberw
* @Classname TurnNumber
* @Description 编写程序，实现三个线程，运行输出 A1 B2 C3 A4 B5 C6 ….. 用公平锁
* @Date 2021-12-28 14:09
*/
public class TurnNumber {
AtomicInteger num = new AtomicInteger(0);
private final ReentrantLock rl = new ReentrantLock(true);
public void show() {
for (; ; ) {
rl.lock();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
String tn = Thread.currentThread().getName();
int i = num.incrementAndGet();
String s = String.format("%s%d", tn, i);
System.out.print(s + " ");
if ("C".equals(tn)) {
System.out.println();
}
rl.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
TurnNumber tn = new TurnNumber();
Thread a = new Thread(tn::show, "A");
Thread b = new Thread(tn::show, "B");
Thread c = new Thread(tn::show, "C");
a.setPriority(Thread.MAX_PRIORITY);
a.start();
b.setPriority(Thread.NORM_PRIORITY);
b.start();
c.setPriority(Thread.MIN_PRIORITY);
c.start();
}
}
方式二：
用join() 方法
package day_12_28.zuoye;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author soberw
* @Classname TurnNumber
* @Description 编写程序，实现三个线程，运行输出 A1 B2 C3 A4 B5 C6 ….. 第二种写法，用join()
* @Date 2021-12-28 14:09
*/
public class TurnNumber2 {
AtomicInteger num = new AtomicInteger(0);
public void show() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
String tn = Thread.currentThread().getName();
int i = num.incrementAndGet();
String s = String.format("%s%d", tn, i);
System.out.print(s + " ");
if ("C".equals(tn)) {
System.out.println();
}
}
public static void main(String[] args) throws InterruptedException {
TurnNumber2 tn = new TurnNumber2();
while (true) {
Thread a = new Thread(tn::show, "A");
Thread b = new Thread(tn::show, "B");
Thread c = new Thread(tn::show, "C");
a.setPriority(Thread.MAX_PRIORITY);
a.start();
a.join();
b.setPriority(Thread.NORM_PRIORITY);
b.start();
b.join();
c.setPriority(Thread.MIN_PRIORITY);
c.start();
c.join();
}
}
}
案例四
创建五个线程并进入等待状态，等两秒后主线程开始并释放全部线程，最后主线程结束
本案例我用的是wait() 与notifyAll()组合形式;
package day_12_27;
import java.util.concurrent.TimeUnit;
/**
* @author soberw
* @Classname WaitAndNotify
* @Description 创建五个线程并进入等待状态，等两秒后主线程开始并释放全部线程，最后主线程结束
* @Date 2021-12-27 15:47
*/
public class WaitAndNotify {
public static void main(String[] args) {
Object co = new Object();
for (int i = 0; i < 5; i++) {
MyThread t = new MyThread("Thread" + i, co);
t.start();
}
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("-----Main Thread notify-----");
synchronized (co) {
//co.notify();
co.notifyAll();
}
TimeUnit.SECONDS.sleep(2);
System.out.println("Main Thread is end.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
static class MyThread extends Thread {
private String name;
private Object co;
public MyThread(String name, Object o) {
this.name = name;
this.co = o;
}
@Override
public void run() {
System.out.println(name + " is waiting.");
try {
synchronized (co) {
co.wait();
}
System.out.println(name + " has been notified.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
案例五
用五个线程实现，求123456789 之间放±和100的表达式，如果一个线程求出结果，立即告诉其它停止。
这里我用到了AtomicBoolean原子类来保证数据的原子性：
package day_12_27.zuoye;
import java.util.Random;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author soberw
* @Classname Number100
* @Description 用五个线程实现，求123456789 之间放+-和100的表达式，如果一个线程求出结果，立即告诉其它停止。
* @Date 2021-12-27 21:14
*/
public class Number100 {
//原子类，保证原子性
AtomicBoolean ab = new AtomicBoolean(true);
public void show() {
String[] ss = {"", "+", "-"};
StringBuilder sbu = new StringBuilder();
sbu.append("1");
Random random = new Random();
while (ab.get()) {
for (int i = 2; i < 9; i++) {
sbu.append(ss[random.nextInt(3)]);
sbu.append(i);
}
Pattern p = Pattern.compile("[0-9]+|-[0-9]+");
Matcher m = p.matcher(sbu.toString());
int sum = 0;
while (m.find()) {
sum += Integer.parseInt(m.group());
}
if (sum == 100) {
ab.set(false);
System.out.println(Thread.currentThread().getName() + ":" + sbu.toString() + " = 100");
}
sbu.delete(1, sbu.length());
}
}
public static void main(String[] args) {
var n = new Number100();
for (int i = 0; i < 5; i++) {
new Thread(n::show).start();
}
}
}
案例六
模拟经典问题，生产者-消费者问题：
方式一：
package day_12_28.zuoye;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author soberw
* @Classname ProductorAndConsumerForLock
* @Description 用线程通信机制解决生产者消费者问题
* @Date 2021-12-28 19:18
*/
public class ProductorAndConsumerForLock {
public static void main(String[] args) {
Clerk1 clerk1 = new Clerk1();
Productor1 pro = new Productor1(clerk1);
Consumer1 con = new Consumer1(clerk1);
new Thread(pro, "生产者 A").start();
new Thread(con, "消费者 B").start();
// new Thread(pro, "生产者 C").start();
// new Thread(con, "消费者 D").start();
}
}
class Clerk1 {
private int product = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
// 进货
public void get() {
lock.lock();
try {
if (product >= 1) { // 为了避免虚假唤醒，应该总是使用在循环中。
System.out.println("产品已满！");
try {
condition.await();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : "
+ ++product);
condition.signalAll();
} finally {
lock.unlock();
}
}
// 卖货
public void sale() {
lock.lock();
try {
if (product <= 0) {
System.out.println("缺货！");
try {
condition.await();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : "
+ --product);
condition.signalAll();
} finally {
lock.unlock();
}
}
}
// 生产者
class Productor1 implements Runnable {
private Clerk1 clerk1;
public Productor1(Clerk1 clerk1) {
this.clerk1 = clerk1;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk1.get();
}
}
}
// 消费者
class Consumer1 implements Runnable {
private Clerk1 clerk1;
public Consumer1(Clerk1 clerk1) {
this.clerk1 = clerk1;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
clerk1.sale();
}
}
}
方式二：
package day_12_28.zuoye;
/**
* @author soberw
* @Classname ProducerAndConsumer
* @Description 用等待唤醒机制解决生产者消费者问题
* @Date 2021-12-28 16:25
*/
public class ProductorAndConsumer {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Productor pro = new Productor(clerk);
Consumer cus = new Consumer(clerk);
new Thread(pro, "生产者 A").start();
new Thread(cus, "消费者 B").start();
new Thread(pro, "生产者 C").start();
new Thread(cus, "消费者 D").start();
}
}
//店员
class Clerk {
private int product = 0;
//进货
public synchronized void get() {//循环次数：0
//为了避免虚假唤醒问题，应该总是使用在循环中
while (product >= 1) {
System.out.println("产品已满！");
try {
this.wait();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : " + ++product);
this.notifyAll();
}
//卖货
public synchronized void sale() {//product = 0; 循环次数：0
while (product <= 0) {
System.out.println("缺货！");
try {
this.wait();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : " + --product);
this.notifyAll();
}
}
//生产者
class Productor implements Runnable {
private Clerk clerk;
public Productor(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
clerk.get();
}
}
}
//消费者
class Consumer implements Runnable {
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
clerk.sale();
}
}
}
案例七
开十个线程打印输出1~10000中偶数的值，计算总耗时
我采用的是闭锁机制：
package day_12_28.zuoye;
import java.util.concurrent.CountDownLatch;
/**
* @author soberw
* @Classname CountTime
* @Description 开十个线程打印输出1~10000中偶数的值，计算总耗时 用闭锁（门栓）
* @Date 2021-12-28 15:22
*/
public class CountTime {
static CountDownLatch cdl = new CountDownLatch(10);
void show() {
for (int i = 0; i < 10000; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
cdl.countDown();
}
public static void main(String[] args) {
CountTime ct = new CountTime();
long start = System.currentTimeMillis();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 10; i++) {
new Thread(ct::show).start();
}
try {
cdl.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println((end - start - 100) + "--------------");
}
}
Java多线程经典案例分享的更多相关文章
- JAVA多线程经典问题 -- 生产者 消费者
工作2年多来一直也没有计划写自己的技术博客,最近辞职在家翻看<thingking in JAVA>,偶尔看到了生产者与消费者的一个经典的多线程同步问题.本人在工作中很少使用到多线程以及高并 ...
- Java基础经典案例
案例列表 01减肥计划switch版本 02减肥计划if版本 03逢七跳过 04不死神兔 05百钱白鸡 06数组元素求和 07判断两个数组是否相同 08查找元素在数组中的索引 09数组元素反转 10评 ...
- Java多线程分析案例
1. 多线程的创建方式 (1).继承 Thread类:但Thread本质上也是实现了Runnable 接口的一个实例,它代表一个线程的实例,并且,启动线程的唯一方法就是通过 Thread 类的 sta ...
- JAVA多线程经典问题 -- 生产者 消费者 同步队列实现方法
在JAVASE5 中的java.util.concurrent.BlockingQueue支持,BlockingQueue是一个接口但是我们通常可以使用LinkedBlockingQueue,它是一个 ...
- 《开源公开课分享》：Java开源框架案例分享
缺乏高端技术人才?缺乏开发标准? 代码复用性低?技术风险难于把控? 招聘成本高?培训成本高? 假设想法不够雄伟,那么就会局限于细节:假设一開始就铺很大的摊子,将会失去控制: ...
- Java多线程经典题目(医院挂号)
题目 实现一个医院的挂号机系统,要求:有多台挂号机同时运行,此时无论有多少患者挂号,要求都能挂到不同 的号码,并且要求实现当意外断电之后,下一次恢复还能从上次结束号码继续挂号? * synchroni ...
- JAVA多线程之生产者 消费者模式 妈妈做面包案例
创建四个类 1.面包类 锅里只可以放10个面包 ---装面包的容器2.厨房 kitchen 生产面包 和消费面包 最多生产100个面包3.生产者4消费者5.测试类 多线程经典案例 import ja ...
- Java多线程中的wait/notify通信模式
前言 最近在看一些JUC下的源码,更加意识到想要学好Java多线程,基础是关键,比如想要学好ReentranLock源码,就得掌握好AQS源码,而AQS源码中又有很多Java多线程经典的一些应用:再比 ...
- java基础知识回顾之java Thread类学习（八）--java多线程通信等待唤醒机制经典应用（生产者消费者）
*java多线程--等待唤醒机制:经典的体现"生产者和消费者模型 *对于此模型,应该明确以下几点: *1.生产者仅仅在仓库未满的时候生产,仓库满了则停止生产. *2.消费者仅仅在有产品的时 ...
随机推荐
- SpringBoot 中拦截器的简介及使用方式
拦截器简介 拦截器通常通过动态代理的方式来执行. 拦截器的生命周期由IoC容器管理,可以通过注入等方式来获取其他Bean的实例,使用更方便. 拦截器配置使用方式 实现拦截器接口: import jav ...
- elasticsearch设置密码
ELK - X-Pack设置用户密码 enable X-Pack security vi elasticsearch.yml #首先开启x-pack插件 xpack.security.enabled: ...
- react中虚拟DOM
简单来说虚拟DOM就是一个js对象,相对于真实dom来做比较更节约性能,虚拟DOM执行过程如下
- Word2010制作收款单
原文链接:https://www.toutiao.com/i6488255406136099342/ 页面设置 选择"页面布局"选项卡,"页面设置"功能组,&q ...
- Word2010制作电子印章
原文链接: https://www.toutiao.com/i6488971642788643341/ 选择"插入"选项卡,"插图"功能组,"形状&q ...
- 二维数组与稀疏数组的转换---dataStructures
首先我们看一个需求 在11 * 11 的五子棋的棋盘中 我们使用0代表十字交叉点也是无效的数据 用1代表黑棋 用2代表蓝棋 那么所看到的棋盘如下 改用数字显示后就如一下样式 现在我们需要将怎个棋盘存储 ...
- vue2如何根据不同的环境配置不同的baseUrl
在正常的开发中,通常我们需要在线上的测试环境中运行代码来检查是否有些线上才会出现的bug或者是问题.每次去特意的修改我们的baseUrl显然是不现实的,而且说不定哪天忘记了估计会被大佬喷死 首先,这是 ...
- VictoriaMerics学习笔记（1）：翻译官方广告
先看看VictoriaMetrics官网网站上是如何作(tree)宣(new)传(bee)的: 官方广告 0.(监控领域)最快解决方案 为高性能而设计 便于安装 支持单机和群集版本 1.更高效的存储空 ...
- manjora20使用体验
#第一次评估 适合小白日常办公,不适合计算机研究人员 ##优点 稳定流畅,运行速度比Ubuntu快很多 界面优美,UI很好 强大的aur软件库应有尽有,几乎是所有软件都有 中国源和arch社区提供的包 ...
- golang中time包日期时间常用用法
package main import ( "fmt" "reflect" "time" ) var week time.Duration ...