实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束

最新推荐文章于 2022-11-30 17:00:58 发布
最新推荐文章于 2022-11-30 17:00:58 发布
阅读量443 收藏
点赞数
分类专栏： 并发编程 文章标签： java 并发编程 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fwfwfwfwfwfwf/article/details/121418716
版权

1、使用传统方式

package com.example.demo.jucpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

/**
 * while(true)形式 持续监听
 * 
 * @author zl
 *
 */
public class CorePoolDemo {

	public static void main(String[] args) {
		ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<Runnable>(100), threadFactory, new ThreadPoolExecutor.AbortPolicy());

		Container container = new Container();
		poolExecutor.execute(new MyThread12(container));
		poolExecutor.execute(new MyThread11(container));
		poolExecutor.shutdown();

	}
}

class MyThread11 implements Runnable {

	private Container container;

	public MyThread11(Container container) {
		this.container = container;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			try {
				TimeUnit.MILLISECONDS.sleep(500);
				System.out.println(Thread.currentThread().getName() + "  t1增加：" + i);
				container.addNumber(i);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class MyThread12 implements Runnable {

	private Container container;

	public MyThread12(Container container) {
		this.container = container;
	}

	@Override
	public void run() {
		System.out.println("t2开始");
		for (;;) {
			try {
				TimeUnit.NANOSECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Integer size = container.getSize();
			if (size >= 5) {
				System.out.println(Thread.currentThread().getName() + " t2结束========--");
				break;
			}
		}
	}
}

需要持续消耗cpu资源

2、wait/notify加同步代码块形式

package com.example.demo.jucpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

/**
 * wait/notify-notifyall 实现，需要synchronized加持
 * 
 * @author zl
 *
 */
public class CorePoolDemo1 {

	public static void main(String[] args) {
		ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<Runnable>(100), threadFactory, new ThreadPoolExecutor.AbortPolicy());

		Container container = new Container();
		Object lockObject = new Object();
		poolExecutor.execute(new MyThread21(container, lockObject));
		poolExecutor.execute(new MyThread22(container, lockObject));

		poolExecutor.shutdown();

	}
}

class MyThread21 implements Runnable {

	private Container container;
	private Object lockObject;

	public MyThread21(Container container, Object lockObject) {
		this.container = container;
		this.lockObject = lockObject;
	}

	@Override
	public void run() {
		synchronized (lockObject) {
			for (int i = 0; i < 10; i++) {

				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e1) {
					e1.printStackTrace();
				}

				System.out.println(Thread.currentThread().getName() + "  t1增加：" + i);
				container.addNumber(i);

				if (container.getSize() == 5) {
					try {
						lockObject.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

			}
		}
	}
}

class MyThread22 implements Runnable {

	private Container container;
	private Object lockObject;

	public MyThread22(Container container, Object lockObject) {
		this.container = container;
		this.lockObject = lockObject;
	}

	@Override
	public void run() {
		System.out.println("t2开始");

		synchronized (lockObject) {
			System.out.println(Thread.currentThread().getName() + " t2结束========--");
			lockObject.notify();
		}

	}
}

3、使用LockSupport实现

package com.example.demo.jucpool;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * LockSupport实现
 * 
 * @author zl
 *
 */
public class CorePoolDemo2 {

	private static Container container = new Container();

	static Thread t1 = null;
	static Thread t2 = null;

	public static void main(String[] args) {

		t1 = new Thread(() -> {
			for (int i = 0; i < 10; i++) {
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e1) {
					e1.printStackTrace();
				}

				System.out.println(Thread.currentThread().getName() + "  t1增加：" + i);
				container.addNumber(i);

				if (container.getSize() == 5) {
					LockSupport.unpark(t2);
					LockSupport.park();
				}

			}
		}, "t1");

		t2 = new Thread(() -> {
			System.out.println("t2开始");
			LockSupport.park();
			System.out.println(Thread.currentThread().getName() + " t2结束========--");
			LockSupport.unpark(t1);
		}, "t2");

		t2.start();
		t1.start();
	}
}

4、 信号量 seamphore实现

package com.example.demo.jucpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

/**
 * 信号量 seamphore实现
 * 
 * @author zl
 *
 */
public class CorePoolDemo3 {

	public static void main(String[] args) {
		ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<Runnable>(100), threadFactory, new ThreadPoolExecutor.AbortPolicy());

		Container container = new Container();
		Semaphore semaphore = new Semaphore(1);
		poolExecutor.execute(new Mythread41(semaphore, container));
		poolExecutor.execute(new Mythread42(semaphore, container));
		poolExecutor.shutdown();
	}
}

class Mythread41 implements Runnable {

	private Semaphore semaphore;
	private Container container;

	public Mythread41(Semaphore semaphore, Container container) {
		this.semaphore = semaphore;
		this.container = container;
	}

	@Override
	public void run() {
		try {
			semaphore.acquire();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		for (int i = 0; i < 10; i++) {

			try {
				TimeUnit.MILLISECONDS.sleep(500);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + "  t1增加：" + i);
			container.addNumber(i);

			if (container.getSize() == 5) {
				semaphore.release();
			}
		}
	}
}

class Mythread42 implements Runnable {

	private Semaphore semaphore;
	private Container container;

	public Mythread42(Semaphore semaphore, Container container) {
		this.semaphore = semaphore;
		this.container = container;
	}

	@Override
	public void run() {
		System.out.println("t2开始");

		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}

		try {
			semaphore.acquire();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println(Thread.currentThread().getName() + " t2结束========--");
		semaphore.release();
	}
}

5、使用ReentrantLock 实现 

package com.example.demo.jucpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

/**
 * 使用ReentrantLock 实现 --lock()/unlock()
 * 
 * @author zl
 *
 */
public class CorePoolDemo4 {

	public static void main(String[] args) {
		ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<Runnable>(100), threadFactory, new ThreadPoolExecutor.AbortPolicy());

		Container container = new Container();
		Lock lock = new ReentrantLock();
		poolExecutor.execute(new Mythread52(lock, container));
		poolExecutor.execute(new Mythread51(lock, container));
		poolExecutor.shutdown();
	}
}

class Mythread51 implements Runnable {

	private Container container;
	private Lock lock;

	public Mythread51(Lock lock, Container container) {
		this.lock = lock;
		this.container = container;
	}

	@Override
	public void run() {
		lock.lock();
		for (int i = 0; i < 10; i++) {
			try {
				TimeUnit.MILLISECONDS.sleep(500);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + "  t1增加：" + i);
			container.addNumber(i);

			if (container.getSize() == 5) {
				lock.unlock();
			}
		}
	}
}

class Mythread52 implements Runnable {

	private Lock lock;
	private Container container;

	public Mythread52(Lock lock, Container container) {
		this.lock = lock;
		this.container = container;
	}

	@Override
	public void run() {
		System.out.println("t2开始");

		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
		lock.lock();
		System.out.println(Thread.currentThread().getName() + " t2结束========--");
		lock.unlock();
	}
}

6、countDownLatch 实现

package com.example.demo.jucpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

/**
 * countDownLatch 实现 ---await/countDown
 * 
 * @author zl
 *
 */
public class CorePoolDemo5 {

	public static void main(String[] args) {
		ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<Runnable>(100), threadFactory, new ThreadPoolExecutor.AbortPolicy());

		Container container = new Container();
		CountDownLatch countDownLatch = new CountDownLatch(1);
		poolExecutor.execute(new Mythread62(countDownLatch, container));
		poolExecutor.execute(new Mythread61(countDownLatch, container));
		poolExecutor.shutdown();
	}
}

class Mythread61 implements Runnable {

	private Container container;
	private CountDownLatch countDownLatch;

	public Mythread61(CountDownLatch countDownLatch, Container container) {
		this.countDownLatch = countDownLatch;
		this.container = container;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			try {
				TimeUnit.MILLISECONDS.sleep(500);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + "  t1增加：" + i);
			container.addNumber(i);

			if (container.getSize() == 5) {
				countDownLatch.countDown();
			}
		}
	}
}

class Mythread62 implements Runnable {

	private CountDownLatch countDownLatch;
	private Container container;

	public Mythread62(CountDownLatch countDownLatch, Container container) {
		this.countDownLatch = countDownLatch;
		this.container = container;
	}

	@Override
	public void run() {
		System.out.println("t2开始");

		try {
			countDownLatch.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + " t2结束========--");

	}
}
*小说家*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
编程题：实现一个容器，提供两个方法，add,size。写两个线程，线程 1 添加 10 个对象到容器中，线程 2 实现监控容器中对象的个数，当个数到 5 个时，线程 2 给出提示并结束。
mabiao6822的博客
09-15 438
import java.util.ArrayList; import java.util.concurrent.TimeUnit; public class Container { volatile ArrayList<Object> list=new ArrayList<>();//volatile保证可见性 private void add(Object ob...
java用线程的两种实现方式设计四个线程两次对J加1两次对J减1
11-19
在上面的代码中，我们定义了一个 Factory 类，该类提供了 add 和 min 两个方法。add 方法将变量 J 加一，而 min 方法将变量 J 减一。这些方法都是同步的，以避免线程安全问题。 线程的创建和启动 在上面的代码中，...
面试题——实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
蓝天的博客
06-09 774
1 用wait和notify实现 public class NotifyFreeLock { volatile List lists = new ArrayList<>(); public void add(Object o) { lists.add(0); } public int size() { return lists.size(); } public static void main(St.
多线程与高并发（11）——经典面试题之实现一个容器，提供两个方法，add，size。
liwangcuihua的博客
08-09 293
实现一个容器，提供两个方法，add，size。写两个线程，线程 1 添加 10 个元素到容器中，线程 2 实现监控元素的个数，当个数到 5 个时，线程 2 给出提示并结束。
实现一个容器，提供两个方法add,size。写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数为5的时候，线程2给出提示并退出，线程1继续执行。
Forest24的博客
04-17 783
关键：容器使用volatile关键字修饰。 方法一： 使用wait(),notify()实现。 package com.example.demo; import java.util.ArrayList; import java.util.List; import java.util.concurrent.TimeUnit; public class Container { //v...
元素超过线程个数时的处理方案
09-21
在多线程编程中，如何有效地处理元素数量超过线程个数的情况是一个常见的挑战。当一个向量（或数组、列表等数据结构）中的元素数量远大于可用线程的数量时，如何分配工作负载以实现最佳性能是关键。下面将详细讨论这...
PyQt5中多线程模块QThread使用方法的实现
12-20
1. 创建一个继承自QThread的子类，例如`MyThread`，并在其中实现`run()`方法，将耗时的操作（如循环添加数字）移到`run()`内。 2. 在`run()`方法中，可以使用`pyqtSignal`来发送信号，通知主线程进行界面更新。这样...
iOS-常驻线程之线程循环调用（两个线程循环交替调用）
06-01
解压并运行这个示例，可以帮助你更好地理解如何在iOS中实现两个线程的循环交替调用。 总结来说，常驻线程在iOS开发中用于后台任务处理，通过GCD或NSOperationQueue可以轻松创建和管理这些线程。通过精心设计的线程...
C#实现AddRange为数组添加多个元素的方法
01-20
在C#编程中，`AddRange`方法是一个非常实用的功能，尤其当需要向集合中批量添加元素时。这个方法主要用于`List<T>`类，但在`ArrayList`类中也有实现。`ArrayList`是.NET Framework早期版本中的一种动态数组，虽然在...
04 面试题系列 | 编程题：实现一个容器，提供两个方法，add,size。写两个线程，线程 1 添加 10 个元素到容器中，线程 2 实现监控元素的个数，当个数到 5 个时，线程 2 给出提示并结束
程序猿杂货铺
03-18 589
题目 实现一个容器，提供两个方法，add,size。写两个线程，线程 1 添加 10 个元素到容器中，线程 2 实现监控元素的个数，当个数到 5 个时，线程 2 给出提示并结束。 用普通线程方法来实现 用 volitile 关键字实现 用 wait 和 notify 实现 使用 latch 替代 wait notify 实现 用普通线程方法来实现 public class MyContaine...
实现一个容器，提供两个方法，add，size；写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
qq_38041439的博客
06-17 143
多线程面试题 实现一个容器，提供两个方法，add，size；写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 1.wait和notify实现 private static List<String> list = new ArrayList<>(); public static void main(String[] args) { Object locak = new Object();
一道面试题：实现一个容器，提供两个方法，add,size 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束线程2
qq_37999559的博客
01-03 189
一道面试题：实现一个容器，提供两个方法，add,size 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束线程2C](这里写自定义目录标题) 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，
【高并发面试题】实现一个容器，提供add和size两个方法，写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，个数到5时，线程2给出提示并结束
wh2880557的博客
11-30 315
【代码】【高并发面试题】实现一个容器，提供add和size两个方法，写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，个数到5时，线程2给出提示并结束。
写两个线程，线程1添加10个元素到容器，线程2对元素个数做监控，个数为5时，线程2给出提示并结束
u013025649的专栏
12-25 552
思路：开启两个线程，线程t1添加元素，线程t2监控元素个数为5。如何保证元素个数为5的时候t2执行，这里就思考如何再元素个数为5的时候t2拿到锁执行，t1等待。直到t2执行完之后t1再拿到锁。 第一种方法: public class waitFiveSecondTest { volatile List list = new ArrayList<>(); pu...
一个容器，两个方法add，size。起两个线程，线程一添加10个元素到容器中，线程二监控容器元素个数，5个时线程二给出提示并结束
Java和算法学习的博客
09-12 137
目录一、sync的wait和notify二、CountDownLatch三、LockSupport 一、sync的wait和notify public class T04 { private static List lists = new ArrayList(); private static void add(Object o) { lists.add(o); } private static int size() { return l
JAVA多线程实现两个线程，线程1负责向容器中添加10个元素，线程2负责监控容器中元素个数，当个数为5时，线程2给出提示并且结束
kunkunliu的博客
05-07 385
JAVA多线程实现两个线程，线程1负责向容器中添加10个元素，线程2负责监控容器中元素个数，当个数为5时，线程2给出提示并且结束 实现一个容器 提供两个方法 add和size 写两个线程，线程1添加10个元素到容器中，线程2实现监控容器中元素的个数，当个数到5个时，线程2给出提示并且结束 实现方式LockSupport中的park （阻塞线程）方法和unpark(Thread) （重新唤醒某个线...
synchronized和volatile关键字
hskw444273663的博客
07-14 189
一、Demo1 1、demo1 package com.hskw.demo1; /** * synchronized关键字 * synchronized关键字锁定的是对象不是代码块,demo中锁的是object对象的实例 * 锁定的对象有两种:1.类的实例 2.类对象(类锁) * 加synchronized关键字之后不一定能实现线程安全，具体还要看锁定的对象是否唯一。 */ pu...
实现一个简略ArrayList, 提供 add(), remove(), size()
muskter的博客
04-19 540
实现一个简略ArrayList, 提供 add(), remove(), size() 没有考虑太多方面，还请批评指正。 接口定义 import java.io.Serializable;public interface PArrayListIT> extends Serializable{ public int add(T t); public int remove(
用Java如何让两个线程调用同一个方法，遍历出字符串中不同的字符
最新发布
07-08
在Java中，可以通过使用两个线程来同时调用同一个方法，并遍历出字符串中的不同字符。下面是一个示例代码，演示了如何实现这个功能： ```java import java.util.HashSet; import java.util.Set; public class Main...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值