JUC相关测试学习代码

最新推荐文章于 2022-02-26 00:02:41 发布
最新推荐文章于 2022-02-26 00:02:41 发布
阅读量501 收藏
点赞数
分类专栏： JUC 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39782583/article/details/91956031
版权
本文通过一系列测试代码深入探讨Java并发编程，包括自旋锁的实现、volatile特性的验证、synchronized与ReentrantLock的可重入性、ArrayList的线程不安全性、读写锁的使用，以及JUC组件如CountDownLatch、CyclicBarrier、Semaphore和SynchronousQueue的实战演示。此外，还涉及多线程间的顺序调用、生产者消费者模式、线程池的实现以及死锁的模拟。最后，简要总结了垃圾收集器的配置。
摘要由CSDN通过智能技术生成

手写一个自旋锁（底层是CAS）

主要就是获得锁lock()的地方应用了CAS

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/*
 * 手写一个自旋锁（底层是CAS）
 */

public class SpinlockDemo {

	// 原子引用，解决JMM中原子性问题,底层是unsafe类，其下面的各个方法是CAS在java中的体现
	AtomicReference<Thread> reference = new AtomicReference<Thread>();

	public void lock() {
		Thread thread = Thread.currentThread();
		System.out.println(Thread.currentThread().getName() + "\t 来了！ ");
		do {
			// 循环
		} while (!reference.compareAndSet(null, thread));

	}

	private void unlock() {
		Thread thread = Thread.currentThread();
		System.out.println(Thread.currentThread().getName() + "\t 释放了锁！ ");
		reference.compareAndSet(thread, null);

	}

	public static void main(String[] args) {
		SpinlockDemo spinlockDemo = new SpinlockDemo();

		new Thread(() -> {
			spinlockDemo.lock();
			// System.out.println(Thread.currentThread().getName() + "\t 来了！ ");
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			spinlockDemo.unlock();
			// System.out.println(Thread.currentThread().getName() + "\t 释放了锁！
			// ");

		}, "first").start();

		new Thread(() -> {
			spinlockDemo.lock();//如果first不释放锁，这个second就一直在这里自旋
			System.out.println(Thread.currentThread().getName() + "\t 终于轮到我了！ ");
			spinlockDemo.unlock();

			// System.out.println(Thread.currentThread().getName() + "\t 释放了锁！
			// ");

		}, "second").start();

	}

}

输出：
first	 来了！ 
second	 来了！ 
first	 释放了锁！ 
second	 终于轮到我了！ 
second	 释放了锁！

单例模式，DCL版+volatile禁止重排


/*
 * 单例模式，DCL版+volatile禁止重排
 */

public class Singleton {

	// 这个地方是懒汉式，如果下面没有if判断，就是饿汉式，防止面试问到
	// 这里加volatile是为了防止指令重排
	private static volatile Singleton instance = null;

	// 精髓之处，将constructor私有化
	private Singleton() {
		System.out.println("dddd");
	}

	public static Singleton getInstance() {
		if (instance == null) {
			// 这里的synchronized是DCL双重锁检测，
			// 就像去房间，先敲门，进去了再按按门，看有没有锁严实，再做事
			synchronized (Singleton.class) {
				if (instance == null) {
					instance = new Singleton();
				}
			}

		}
		return instance;

	}
	
	//test
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			new Thread(()->Singleton.getInstance(),String.valueOf(i)).start();;
			
		}	
		
		
	}

}

测试volatile保证可见性

import java.util.concurrent.TimeUnit;

/*
 * 测试volatile保证可见性
 */

public class Seeable {

	// 外部类可以通过实例访问内部类的私有变量
	static class MyData {
		private int num = 0;
		// private volatile int num = 0; 此处加上volatile保证可见性

		public void changeData() {
			this.num = 10;
		}

	}

	public static void main(String[] args) {
		MyData myData = new MyData();

		// 乃木达表达式，期间用TimeUnit让线程休眠3秒
		new Thread(() -> {
			System.out.println(Thread.currentThread().getName() + " come in");
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			// 改变数据
			myData.changeData();

			System.out.println("num = " + myData.num);

		}, "Ding").start();

		// 如果num没有用colatile修，那么mian和Ding线程之间是不可见的，对于main来说，num一直为0，就会一直在这里循环，出不去
		while (myData.num == 0) {

		}
		// 如果num加了volatile修饰，就会执行到这里，并打印这句话
		System.out.println(Thread.currentThread().getName() + " mission complete");

	}

}

测试volatile不保证原子性

import java.util.concurrent.atomic.AtomicInteger;

/*
 * 测试volatile不保证原子性
 */

class MyData {
	volatile int num = 1;

	public void addNum() {
		num++;
	}

	// 因为colatile不保证原子性，这里用JUC里面的AtomicInteger类，构造函数里面的值是初始化value，默认为0
	AtomicInteger atomicInteger = new AtomicInteger(1);

	public void atomicAddNum() {
		atomicInteger.getAndAdd(1); // 相当于i++,参数是每次加多少

	}

}

public class AtonicTest {

	public static void main(String[] args) {
		MyData myData = new MyData();

		for (int i = 0; i < 20; i++) {

			new Thread(() -> {
				for (int j = 0; j < 1000; j++) {
					// myData.addNum();
					// 这里用AtomicInteger类的方法，保证原子性
					myData.atomicAddNum();

				}

			}, String.valueOf(i)).start();

		}

		// 如果后台线程大于2(后台默认有一个main和GC线程)，就让线程继续执行
		while (Thread.activeCount() > 2) {
			Thread.yield();
		}

		System.out.println("最终的num值是： " + myData.atomicInteger);

	}

}

测试syn可重入锁


/*
 * 测试syn可重入锁
 */

public class SynDemo {

	static class Phone {
		public synchronized void getName() {
			System.out.println(Thread.currentThread().getName() + "   getName");
			getId();
		}

		public synchronized void getId() {
			System.out.println(Thread.currentThread().getName() + "   getId");
		}

	}

	public static void main(String[] args) {
		Phone phone = new Phone();

		new Thread(() -> phone.getName(), "first").start();

		new Thread(() -> phone.getName(), "second").start();

	}

}

测试ReentrantLock可重入锁

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

/*
 * 测试ReentrantLock可重入锁
 */

public class ReentrantDemo {
	public static ReentrantLock lock = new ReentrantLock();

	public static void getName() {
		lock.lock();
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + "  getName()");
			getId();
		} finally {
			lock.unlock();
		}
	}

	public static void getId() {
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + "  getId()");
		} finally {
			lock.unlock();
		}
	}

	public static void main(String[] args) {

		new Thread(() -> getName(), "first").start();
		new Thread(() -> getName(), "second").start();
	}

}

ArrayList线程不安全示范:add方法没有加syn

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;

/*
 * ArrayList线程不安全示范:add方法没有加syn
 */

public class ContainerNotSafeDemo {

	public static void main(String[] args) {
		
		//1、用vector：List<Integer> list = new Vector<Integer>();
		//2、用集合类Collections：List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>());
		List<Integer> list = new CopyOnWriteArrayList<Integer>();

		// 会引发并发修改异常：java.util.ConcurrentModificationException
		for (int i = 0; i < 30; i++) {
			new Thread(() -> {
				list.add(3);
				System.out.println(list);
			}).start();
		}
		
	}

}

测试读写锁

import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
 * 读写锁
 */

class Source {

	volatile HashMap<String, Object> map = new HashMap<String, Object>();
	//可重复写入的读写锁，只要是在写，其他线程都不能读或写
	ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();

	public void set(String str, Object obj) {
		try {
			rwlock.writeLock().lock();

			System.out.println(Thread.currentThread().getName() + "-正在写入：" + str);
			map.put(str, obj);
			System.out.println(Thread.currentThread().getName() + "-写入完成");

		} finally {

			rwlock.writeLock().unlock();
		}

	}

	public void get(String str) {

		try {
			rwlock.writeLock().lock();

			System.out.println(Thread.currentThread().getName() + "-正在读取");
			Object object = map.get(str);
			System.out.println(Thread.currentThread().getName() + "-读取完成" + object);
		} finally {

			rwlock.writeLock().unlock();
		}

	}

}

public class ReadWriteLockDemo {

	public static void main(String[] args) {

		Source source = new Source();
		for (int i = 0; i < 5; i++) {
			final int temp = i;
			new Thread(() -> {
				source.set(temp + "", temp + "");
			}, String.valueOf(i)).start();

		}
		// 睡眠2秒，保证写操作全部完成
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		for (int i = 0; i < 5; i++) {
			final int temp = i;
			new Thread(() -> {
				source.get(temp + "");
			}, String.valueOf(i)).start();

		}

	}

}

输出：
1-正在写入：1
1-写入完成
0-正在写入：0
0-写入完成
2-正在写入：2
2-写入完成
3-正在写入：3
3-写入完成
4-正在写入：4
4-写入完成
0-正在读取
0-读取完成0
2-正在读取
2-读取完成2
1-正在读取
1-读取完成1
4-正在读取
4-读取完成4
3-正在读取
3-读取完成3

JUC.CountDownLatch的测试Demo

首先创建一个枚举类：


/*
 * CountDownLatch的枚举类
 */

public enum StudentEnum {

	one(1, "赵"), two(2, "钱"), three(3, "孙"), fore(4, "李"), five(5, "周"), six(6, "吴");

	private Integer num;
	private String name;

	public Integer getNum() {
		return num;
	}

	public String getName() {
		return name;
	}

	private StudentEnum(Integer num, String name) {
		this.num = num;
		this.name = name;
	}

	public static StudentEnum forEach(int index) {
		StudentEnum[] enums = StudentEnum.values();
		for (StudentEnum studentEnum : enums) {
			if (studentEnum.getNum() == index) {
				return studentEnum;
			}
		}
		return null;

	}

}

再来测试类：

import java.util.concurrent.CountDownLatch;

/*
 *  CountDownLatch测试
 */

public class CountDownLatchDemo {
	
	static CountDownLatch countDownLatch = new CountDownLatch(6);
	
	public static void main(String[] args) throws InterruptedException {
		
		for (int i = 1; i <= 6 ; i++) {
			
			final int tem = i;
			new Thread(()->{
				System.out.println(StudentEnum.forEach(tem).getName() + "同学走了");
				countDownLatch.countDown();
			}).start();
		}
		
		countDownLatch.await();
		System.out.println(Thread.currentThread().getName() + "：############班长锁门");
		
		
	}
	
}



输出：

赵同学走了
孙同学走了
钱同学走了
周同学走了
吴同学走了
李同学走了
main：############班长锁门（不使用CountDownLatch的话，班长就不会在最后锁门了）

JUC.CyclicBarrier测试Demo

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/*
 *  CyclicBarrierDemo
 */

public class CyclicBarrierDemo {

	public static void main(String[] args) {
		CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
			System.out.println("神龙，出来吧！");
		});

		for (int i = 1; i <= 7; i++) {
			final int temp = i;
			new Thread(() -> {
				System.out.println("收集到第" + temp + "个龙珠");

				//这里加一个await()方法，就可以在七颗龙珠还没有收集完之前都在等待
				try {
					cyclicBarrier.await();
				} catch (InterruptedException | BrokenBarrierException e) {
					e.printStackTrace();
				}
			}).start();
		}

	}
	
	输出：
	收集到第1个龙珠
	收集到第2个龙珠
	收集到第3个龙珠
	收集到第5个龙珠
	收集到第6个龙珠
	收集到第7个龙珠
	收集到第4个龙珠
	神龙，出来吧！


}

JUC.Semaphore的测试Demo

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/*
 * SemaphoreDemo 
 */
public class SemaphoreDemo {

	public static void main(String[] args) {
		// 海底捞空3个座位
		Semaphore semaphore = new Semaphore(3);

		// 有6个人在等待
		for (int i = 1; i <= 7; i++) {

			new Thread(() -> {
				try {
					semaphore.acquire();
					System.out.println(Thread.currentThread().getName() + "获得座位");
					TimeUnit.SECONDS.sleep(3);// 吃饭三秒
					System.out.println(Thread.currentThread().getName() + "吃完走人");
				} catch (InterruptedException e) {
					e.printStackTrace();
				} finally {
					semaphore.release();
				}

			},String.valueOf(i)).start();

		}

	}

}


输出：

1获得座位
2获得座位
3获得座位
3吃完走人
1吃完走人
2吃完走人
5获得座位
7获得座位
4获得座位
5吃完走人
7吃完走人
6获得座位
4吃完走人
6吃完走人

JUC.SynchronousQueue的测试Demo

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/*
 * SynchronousQueue测试
 */

public class SynchronousQueueDemo {

	// SynchronousQueue不存储数据，只能每次put一个，等到take了之后才能继续take

	public static void main(String[] args) {

		SynchronousQueue<Integer> synqueue = new SynchronousQueue<Integer>();

		new Thread(() -> {
			try {
				// 加入
				System.out.println(Thread.currentThread().getName() + " put 1");
				synqueue.put(1);

				System.out.println(Thread.currentThread().getName() + " put 2");
				synqueue.put(2);

				System.out.println(Thread.currentThread().getName() + " put 3");
				synqueue.put(3);

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

		new Thread(() -> {
			try {
				TimeUnit.SECONDS.sleep(3);
				System.out.println(Thread.currentThread().getName() + "拿到了：" + synqueue.take());

				TimeUnit.SECONDS.sleep(3);
				System.out.println(Thread.currentThread().getName() + "拿到了：" + synqueue.take());

				TimeUnit.SECONDS.sleep(3);
				System.out.println(Thread.currentThread().getName() + "拿到了：" + synqueue.take());

			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}).start();

	}

}

输出：

first put 1
Thread-0拿到了：1
first put 2
Thread-0拿到了：2
first put 3
Thread-0拿到了：3

题目：多线程之间顺序调用

要求如下：

AA打印5次，BB打印10次，CC打印15次
循环10轮

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

/*
 * 题目：顺序打印A-B-C
 * AA打印5次，BB打印10次，CC打印15次,然后循环10轮
 */

class Ding {
	private int flagNum = 1;
	private ReentrantLock lock = new ReentrantLock();
	private Condition c1 = lock.newCondition();
	private Condition c2 = lock.newCondition();
	private Condition c3 = lock.newCondition();

	private void print(int num) {
		for (int i = 1; i <= num; i++) {
			System.out.println(Thread.currentThread().getName() + "\t " + i);
		}
	}

	public void print5() {
		lock.lock(); // 加锁
		try {

			while (flagNum != 1) { // 如果flag不是1，等待
				c1.await();
			}
			print(5); // 打印5次
			flagNum = 2; // 将flag变为2
			c2.signal(); // 唤醒c2

		} catch (Exception e) {
		} finally {
			lock.unlock(); // 释放锁
		}

	}

	public void print10() {
		lock.lock();
		try {

			while (flagNum != 2) {
				c2.await();
			}
			print(10);
			flagNum = 3;
			c3.signal();

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

	public void print15() {
		lock.lock();
		try {

			while (flagNum != 3) {
				c3.await();
			}
			print(15);
			flagNum = 1;
			c1.signal();

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

}

public class LockConditionDemo {

	public static void main(String[] args) {
		Ding ding = new Ding();

		for (int i = 0; i < 5; i++) {
			new Thread(() -> {
				ding.print5();
			}, "AA").start();

			new Thread(() -> {
				ding.print10();
			}, "BB").start();

			new Thread(() -> {
				ding.print15();
			}, "CC").start();
		}

	}

}

自测小题目：A生产一个B消费一个

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

/*
 * 自测：A生产一个B消费一个
 */

class PrintOneByOneResource {
	private volatile Integer num = 1;
	
	ReentrantLock lock = new ReentrantLock();
	
	private Condition cpro = lock.newCondition();
	private Condition ccon= lock.newCondition();

	public void product() {
		lock.lock();
		try {
			
			while (num != 1) {
				cpro.await();
				
			}

			System.out.println(Thread.currentThread().getName() + "生产了一个");
			num = 2;
			ccon.signal();

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

	}

	public void consume() {
		lock.lock();
		try {
			while (num != 2) {
				ccon.await();				
			}

			System.out.println(Thread.currentThread().getName() + "消费了一个");
			num = 1;
			cpro.signal();
		} catch (Exception e) {
		} finally {
			lock.unlock();
		}

	}

}

public class PrintOneByOne {

	public static void main(String[] args) {
		PrintOneByOneResource source = new PrintOneByOneResource();
		for (int i = 0; i < 20; i++) {
			new Thread(() -> {
				source.product();

			}, "A").start();

			new Thread(() -> {
				source.consume();

			}, "B").start();
		}

	}

}

生产者消费者模式-阻塞队列版

要求：生产一个消费一个，然后可以停止（不用syn，不用锁，用阻塞队列和原子引用）

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/*
 * 生产者消费者模式-阻塞队列版
 * 要求：生产一个消费一个，然后可以停止
 * 
 */

class ProdConsResource {
	private volatile boolean flag = true; // 生产消费的flag

	private AtomicInteger atomicInteger = new AtomicInteger(); // 原子引用，用来做++i操作

	private BlockingQueue<String> blockingQueue; // 阻塞队列，这里用超时的方法 offer poll

	// 这里的BlockingQueue是一个接口，我们在资源类的constructor里面再定义
	public ProdConsResource(BlockingQueue<String> blockingQueue) {
		super();
		this.blockingQueue = blockingQueue;
	}

	public void product() throws InterruptedException {
		String data = null;
		boolean ret;
		while (flag) {
			data = atomicInteger.incrementAndGet() + "";
			ret = blockingQueue.offer(data, 2, TimeUnit.SECONDS);
			if (ret) {
				System.out.println(Thread.currentThread().getName() + "进入队列" + data + "成功");
			} else {
				System.out.println(Thread.currentThread().getName() + "进入队列失败" + data + "失败");

			}
			TimeUnit.SECONDS.sleep(1);
		}
		
	}

	public void consumer() throws InterruptedException {
		String result = null;
		while (flag) {
			result = blockingQueue.poll(2, TimeUnit.SECONDS);
			if (null == result || result.equalsIgnoreCase("")) {
				flag = false;
				System.out.println(Thread.currentThread().getName() + "超过俩秒中没有拿到蛋糕，消费停止");
				return;
			}
			

			System.out.println(Thread.currentThread().getName() + "从队列中消费" + result);
		}
		//这个地方实现先后消费是靠sleep(1),之前是靠唤醒，这个靠时间会不会有点问题？
		TimeUnit.SECONDS.sleep(1);

	}

	public void stop() {
		this.flag = false;
	}

}

public class ProdConsumerBlockQueueDemo {

	public static void main(String[] args) throws InterruptedException {
		ProdConsResource resource = new ProdConsResource(new ArrayBlockingQueue<String>(10));

		new Thread(() -> {

			try {
				resource.product();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}, "product").start();

		new Thread(() -> {

			try {
				resource.consumer();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}, "consumer").start();

		TimeUnit.SECONDS.sleep(5);
		System.out.println("boss拉闸");
		resource.stop();

	}

用ThreadPoolExecutor手写一个线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

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

		/*
		 * ExecutorService threadpool01 = Executors.newFixedThreadPool(5);
		 * ExecutorService threadpool02 = Executors.newSingleThreadExecutor();
		 * ExecutorService threadpool03 = Executors.newCachedThreadPool();
		 * ExecutorService threadpool04 = Executors.newScheduledThreadPool(3);
		 */

		ExecutorService threadpool = new ThreadPoolExecutor(3, 5, 1L, TimeUnit.SECONDS,
				new LinkedBlockingDeque<Runnable>(2), Executors.defaultThreadFactory(),
				new ThreadPoolExecutor.DiscardOldestPolicy());

		for (int i = 1; i <= 10; i++) {

			threadpool.execute(() -> {
				System.out.println(Thread.currentThread().getName() + "处理了业务");

			});
		}

	}
}

手写一个死锁

/*
 * 手写一个死锁
 */
public class HoldThread {

	public static void main(String[] args) {

		String lockA = "AAA";
		String lockB = "BBB";

		new Thread(() -> {
			synchronized (lockA) {
				System.out.println(Thread.currentThread().getName() + "自己持有" + lockA + "他想要" + lockB);
				synchronized (lockB) {
					System.out.println(Thread.currentThread().getName() + "自己持有" + lockB + "他想要" + lockA);

				}
			}

		}, "first:").start();

		new Thread(() -> {
			synchronized (lockB) {
				System.out.println(Thread.currentThread().getName() + "自己持有" + lockB + "他想要" + lockA);
				synchronized (lockA) {
					System.out.println(Thread.currentThread().getName() + "自己持有" + lockA + "他想要" + lockB);
				}
			}

		}, "second:").start();

	}

}

輸出：

first:自己持有AAA他想要BBB
second:自己持有BBB他想要AAA

垃圾收集器配置总结

在这里插入图片描述

馬冬梅啊
关注
专栏目录
JUC学习 - 锁升级
TyuIn的博客
12-07 658
一、synchronized 的简单回顾 synchronized 锁有四种状态，无锁、偏向锁、轻量级锁、重量级锁。这几个状态会随着竞争状态逐渐升级，锁可以升级但不能降级，但是偏向锁状态可以被重置为无锁状态。 二、锁升级 1、偏向锁 经过 HotSpot 的作者大量的研究发现大多数时候是不存在锁竞争的，经常是一个线程多次获得同一个锁，因此如果每次都要竞争锁会增大很多没有必要付出的代价，为了降低获取锁的代价，才引入的偏向锁。核心思想： 如果一个线程获得了锁，那么锁就进入偏向模式，此时 Mark Word
JUC测试
m0_52599076的博客
03-09 104
package syn; import java.util.concurrent.CopyOnWriteArrayList; //测试JUC安全类型的集合 public class TestJUC { public static void main(String[] args) { CopyOnWriteArrayList list=new CopyOnWriteArrayList<String >(); for (int i = 0; i ...
JAVA-JUC的代码学习笔记-练习可以提高，java代码
java技术专家全栈成长之路
01-14 366
自己学习的时候可以自定义注解可以学习用，标志方便清晰； RetentionPolicy.SOURCE -- 加载不运行 注解1，不推荐写法 /** * 课程里用来标记【不推荐】的类或者写法 */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.SOURCE) public @interface NotRecommend { ...
juc部分工具类使用-并发测试
larva_s的博客
03-28 362
文章目录1. 工具1.1 CountDownLatch：线程等待1.2 CyclicBarrier：栅栏，控制线程同时到达某个阶段1.3 Phaser：多阶段栅栏2. 实际使用2.1 CountDownLatch结合Phaser2.2 CountDownLatch结合CyclicBarrier3. 参考链接 1. 工具 1.1 CountDownLatch：线程等待 ​ 比如在测试并发时，主...
个人对juc的一些测试代码
charm_of_code的博客
07-21 263
最近对juc挺杆兴趣的，因为个人原因本身挺喜欢多线程，因为JUC是处理高并发的特别好的工具，因此最近一直在学习，希望大家能互相学习，在这是我对一些JUC的一些类的测试代码， /*这里是对LinkedBlockingQueue的测试 public class TestLinkedBlockingQueue { public static void main(String[] arg
iOS多线程面试题-启动三个线程A，B，C，打印10次 按照ABC的顺序输出（异步转同步）...
weixin_34405925的博客
06-19 1194
题目： 启动三个线程A，B，C，打印10次 按照ABC的顺序输出 1. OC 使用NSLock NSLock *lockA = [[NSLock alloc] init]; NSLock *lockB = [[NSLock alloc] init]; NSLock *lockC = [[NSLock alloc] init]; [lockB lock];...
JUC代码收集，java高并发多线程学习
03-31
本资源"JUC代码收集，java高并发多线程学习"显然是一个专注于探讨和学习JUC库的资料包。 JUC库包含多个子包，如`concurrent`, `atomic`, `locks`等，每个子包都有其特定的功能和用途： 1. **concurrent**：这是JUC...
JUC并发编程学习笔记
Melekh_的博客
02-26 528
一、什么是JUC JUC指的是：Java里的三个包 java.util.concurrent java.util.concurrent.atomic：原子性 java.util.concurrent.locks：lock锁 二、线程和进程 1.进程 程序执行的一次过程，一个进程包含一个或多个线程。进程是资源分配的单位。 2.线程 可以指程序执行过程中，负责实现某个功能的单位。线程是CPU调度和执行的单位。 3.并发 同一时刻，多个线程交替执行。（一个CPU交替执行线程） 4.并行 同一时
JUC并发编程入门学习笔记（狂神说）
Free的午后
08-06 1173
因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！ 1. 什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 2. 线程和进程 进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位 一个进程往往可以包含多个线程，至少包含一个 1）进程 一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线..
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
实现交替控制线程
haogexiaole的博客
11-11 175
1.实现如下结果12A34B56C78D910E1112F1314G1516H1718I1920J2122K2324L2526M2728N2930O3132P3334Q3536R3738S3940T4142U4344V4546W4748X4950Y5152Z import java.util.concurrent.locks.Condition; import java.util.concur...
JUC学习笔记（4）—多线程之间按顺序调用
java_kider的博客
07-31 348
多线程之间按顺序调用，实现A-&gt;B-&gt;C 三个线程启动，要求如下： AA打印5次，BB打印10次，CC打印15次   接着 AA打印5次，BB打印10次，CC打印15次    。来10轮     public class ThreadOrderAccess { public static void main(String[] args) { ShareResource s...
多线程与并发小Demo
weixin_37121451的博客
06-19 1188
3个售票员，卖30张票 package com.javase.thread; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class Ticket {      private int number = 30;
多线程之间按顺序调用，实现A->B->C三个线程启动（使用Lock锁）
热门推荐
BestQiang的博客
05-17 1万+
题目：多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下： AA打印5次，BB打印10次，CC打印15次 …来十轮 思路：使用Lock锁的多个Condition实现精准唤醒。 package com.bestqiang.thread.Queue; /** * @author BestQiang */ import java.util.concurrent.loc...
OBS-Studio-30.2.3-Windows.zip
最新发布
09-23
OBS-Studio-30.2.3-Windows.zip
ChanjeeDlnaTool-v1.0 推送电脑上的文件到安卓电视大屏，实现音视频播放和apk安装
09-23
详情参考：https://blog.csdn.net/title71/article/details/142462255?spm=1001.2014.3001.5501 文件里面含有视频使用教程 一.windows+Android大屏 使用投送教程： 准备 0.电视机和电脑要在同一网络下面 1.使用u盘安装chanjeeDlnaTool.apk到电视机 2.将Windows软件拷贝到合适目录，将.mp4 /.flac /.jpg ...文件拷贝到软件目录的www/files文件夹下面 投送 1.打开Android电视机大屏的刚安装的软件，找到左上角显示的电视机的ip地址 2.双击打开Windows软件的ChanjeeDlnaTool.exe文件，有弹窗提示防火墙网络，请点击允许 3.在Windows软件的ip地址栏输入Android电视机大屏上面的ip地址，并在Windows软件点击认证 4.认证完成后Windows软件下方蓝字会提示Binging successful 就说明绑定成功，此时就可以在Windows软件选择本地文件向Android大屏投送文件了
CODESYS是PLC软件编程工具.docx
09-23
CODESYS是一款功能强大的PLC（可编程逻辑控制器）软件编程工具，广泛应用于工业自动化领域。以下是对CODESYS的详细介绍： 一、基本概述 定义：CODESYS是Controlled Development System的缩写，是可编程逻辑控制PLC的完整开发环境。 开发商：CODESYS软件商是德国Smart software solution GmbH，该公司位于德国巴伐利亚州肯普腾市。 最新版本：CODESYS V3（国内PLC用户使用的版本多为CODESYS V2.3）。V3版本在软件架构上有了很大的改善，朝安全软件的方向发展，正在申请TUV关于EN 61508的SIL认证。 二、主要特点 开放性：CODESYS是一个开放的软件平台，允许第三方开发者在其上开发定制化的解决方案，适应不同厂商的PLC设备，具有很高的灵活性和扩展性。 跨平台：CODESYS可以运行在多种不同的操作系统上，包括Windows、Linux和嵌入式系统（RTOS），提高了开发效率和可移植性。 多语言支持：支持IEC61131-3标准下的IL、ST、FBD、LD、CFC、SFC六种PLC编程语言，用
广西中医药大学在湖南2021-2024各专业最低录取分数及位次表.pdf
09-23
全国各大学在湖南2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
Java并发编程：JUC学习笔记与线程安全解决方案
"这是一份关于Java并发编程(JUC)的学习笔记，主要涵盖了虚假唤醒问题、线程不安全的集合处理以及多线程锁的使用等核心知识点。作者通过示例代码展示了各种问题的解决方案，并介绍了锁的工作原理。" ### 一、虚假...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值