Java 并发编程(一)-JUC

已于 2023-12-16 23:06:53 修改
阅读量650 收藏 1
点赞数 2
分类专栏： java线程 文章标签： java
于 2022-04-02 23:31:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42472027/article/details/123931091
版权

目录

一、并发编程

1、Lock接口

面试：Lock与Synchronized的区别？用新的Lock有什么好处?举例说说?

2、线程间的通信

2.1、synchronized通信示例

解决虚假唤醒问题

2.2、Lock通信示例：

2.3、线程间定制化通信

3、集合的线程安全

3.1、List集合线程不安全示例

1、Vector示例：

2、Collections示例：

3、CopyOnWriteArrayList示例：

4、CopyOnWriteArrayList源码原理：

3.2、HashSet线程不安全演示

1、CopyOnWriteArraySet示例：

3.3、HashMap线程不安全演示

1、ConcurrentHashMap示例：

一、并发编程

    JUC就是java.util.concurrent工具包的简称，这是一个处理线程的工具包，JDK1.5开始出现的。

    管程：又称Monitor监视器，又是锁：是一种同步的机制，保证同一时间，只有一个线程访问被保护的数据或代码。

    用户线程：自定义线程基本都是用户线程。通过Thread.currentThread().isDaemon()来判断是否是用户线程，等于 false是用户线程。等于true 是守护线程。

    守护线程：特殊线程，运行在后台，比如：垃圾回收

    设置守护线程：  线程.setDaemon(true); 在执行start()之前设置。

1、主线程结束了，用户线程还在运行，jvm存活。

2、没有用户线程了，都是守护线程，jvm结束。

1、Lock接口

Lock中常用方法: 
1.void lock():获取锁。 
2.void lockInterruptibly():如果当前线程未被中断，则获取锁。 
3.Condition newCondition():返回绑定到此 Lock 实例的新 Condition 实例。 
4.boolean tryLock():仅在调用时锁为空闲状态才获取该锁。 
5.boolean tryLock(long time, TimeUnit unit):如果锁在给定的等待时间内空闲，
并且当前线程未被中断，则获取锁。 
6.void unlock():释放锁。
Condition接口
//@since 1.5
public interface Condition {

Condition接口中常用方法
1.void await():造成当前线程在接到信号或被中断之前一直处于等待状态。 
2.boolean await(long time, TimeUnit unit):造成当前线程在接到信号、被中断或到达指定
等待时间之前一直处于等待状态。 
3.long awaitNanos(long nanosTimeout):造成当前线程在接到信号、被中断或到达指定等待时
间之前一直处于等待状态。 
4.void awaitUninterruptibly():造成当前线程在接到信号之前一直处于等待状态。 
5.boolean awaitUntil(Date deadline):造成当前线程在接到信号、被中断或到达指定最后期
限之前一直处于等待状态。 
6.void signal():唤醒一个等待线程。 
7.void signalAll():唤醒所有等待线程。

面试：Lock与Synchronized的区别？用新的Lock有什么好处?举例说说?

    Lock不是Java语言内置的，Synchronized是Java语言的关键字，因此是内置特性。

    Synchronized不需要用户手动释放锁，当Synchronized方法或者Synchronized代码块执行完之后，系统会自动让线程释放对锁的占用，而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁的现象。

1、原始构成

    synchronized是关键字属于JVM层面，monitorenter(底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象只有在同步块或方法中才能调wait/notify等方法)

monitorexit

    Lock是具体类(java.util.concurrent.Locks.Lock)是api层面的锁。

2、使用方法

synchronized不需要用户去手动释放锁，当synchronized代码执行完成后系统会自动让线程释放对锁的占用

ReentrantLock则需要用户去手动释放锁，若没有主动释放锁，就有可能导致出现死锁现象

3、等待是否可中断

synchronized不可中断，除非抛出异常或者正常运行完成

ReentrantLock可中断

        1.设置超时方法tryLock(long timeout,TimeUnit unit)

        2.lockInterruptibly()放代码块中，调用interrupt()方法可中断

4、加锁是否公平

synchronized非公平锁

ReentrantLock两者都可以，默认非公平锁

5、锁绑定多个条件Condition

synchronized没有

ReentrantLock用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程

示例：

import java.util.concurrent.locks.ReentrantLock;

public class LockSaleTicket {

	public static void main(String[] args) {
		LockTicket lockTicket = new LockTicket();
		new Thread(()-> {
			for (int i = 0; i < 40; i++) {
				lockTicket.sale();
			}
		},"aa").start();
		new Thread(()-> {
			for (int i = 0; i < 40; i++) {
				lockTicket.sale();
			}
		},"bb").start();
		new Thread(()-> {
			for (int i = 0; i < 40; i++) {
				lockTicket.sale();
			}
		},"cc").start();
	}
	
}

class LockTicket{
	
	private int number = 30;
	
	private final ReentrantLock lock = new ReentrantLock();
	
	//卖票方法
	public void sale() {
		lock.lock();
		try {
			if (number >0) {
				System.out.println(Thread.currentThread().getName() + ":卖出" + (number--)+" 剩余:"+number);
			}
		} finally {
			lock.unlock();
		}
	}
	
}

2、线程间的通信

一个线程+1，一个线程-1交替运行。即线程之间通信。

2.1、synchronized通信示例

/**
 * 线程通信的例子:有2个线程实现对一个初始值是0的变量
 * 		一个线程对值+1、一个线程对值-1
 * 		A线程  1 			B线程  0 
 * 		A线程  1 			B线程  0 
 * 		A线程  1 			B线程  0 
 * 		....
 */
class Share{
	//初始值
	private int number = 0;
	//+1方法
	public synchronized void add() throws InterruptedException {
		if (number != 0) {//number不是0，等待
			wait();
		}
		number++;//number值是0就+1
		System.out.println(Thread.currentThread().getName() + " :: " + number);
		notifyAll();
	}
	//-1方法
	public synchronized void subtract() throws InterruptedException {
		if (number != 1) {//number不是1，等待
			wait();
		}
		number--;//number值是1就-1
		System.out.println(Thread.currentThread().getName() + " :: " + number);
		notifyAll();
	}
	
}

public class ThreadDemo1 {

	public static void main(String[] args) {
		Share share = new Share();
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.add();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"A").start();
		
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.subtract();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"B").start();
	}
	
}

结果：

A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0

上面示例如果再增加2个线程一个+1，一个-1.结果还是正确的吗？

/**
 * 线程通信的例子:有2个线程实现对一个初始值是0的变量
 * 		一个线程对值+1、一个线程对值-1
 * 		A线程  1 			B线程  0 
 * 		A线程  1 			B线程  0 
 * 		A线程  1 			B线程  0 
 * 		....
 */
class Share{
	//初始值
	private int number = 0;
	//+1方法
	public synchronized void add() throws InterruptedException {
		if (number != 0) {//number不是0，等待
			wait();
		}
		number++;//number值是0就+1
		System.out.println(Thread.currentThread().getName() + " :: " + number);
		notifyAll();
	}
	//-1方法
	public synchronized void subtract() throws InterruptedException {
		if (number != 1) {//number不是1，等待
			wait();
		}
		number--;//number值是1就-1
		System.out.println(Thread.currentThread().getName() + " :: " + number);
		notifyAll();
	}
	
}

public class ThreadDemo1 {

	public static void main(String[] args) {
		Share share = new Share();
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.add();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"A").start();
		
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.subtract();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"B").start();
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.add();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"C").start();
		
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.subtract();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"D").start();
	}
	
}

结果：

A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
C :: 1
A :: 2
C :: 3
B :: 2
C :: 3
A :: 4
C :: 5
B :: 4
C :: 5
A :: 6
C :: 7
D :: 6
B :: 5
D :: 4
C :: 5
A :: 6
C :: 7
D :: 6
B :: 5
D :: 4
C :: 5
D :: 4
C :: 5
D :: 4
C :: 5
D :: 4

结果和预期结果不符。原因是虚假唤醒问题。

解决虚假唤醒问题

wait()在哪里睡，就在哪里醒

解决方式：把if判断换成while判断，等线程醒来之后会继续进行判断，不满足条件继续睡，直到满足条件继续往下执行。

/**
 * 线程通信的例子:有2个线程实现对一个初始值是0的变量
 * 		一个线程对值+1、一个线程对值-1
 * 		A线程  1 			B线程  0 
 * 		A线程  1 			B线程  0 
 * 		A线程  1 			B线程  0 
 * 		....
 */
class Share{
	//初始值
	private int number = 0;
	//+1方法
	public synchronized void add() throws InterruptedException {
		while (number != 0) {//number不是0，等待
			wait();
		}
		number++;//number值是0就+1
		System.out.println(Thread.currentThread().getName() + " :: " + number);
		notifyAll();
	}
	//-1方法
	public synchronized void subtract() throws InterruptedException {
		while (number != 1) {//number不是1，等待
			wait();
		}
		number--;//number值是1就-1
		System.out.println(Thread.currentThread().getName() + " :: " + number);
		notifyAll();
	}
	
}

public class ThreadDemo1 {

	public static void main(String[] args) {
		Share share = new Share();
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.add();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"A").start();
		
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.subtract();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"B").start();
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.add();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"C").start();
		
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.subtract();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"D").start();
	}
	
}

结果：

A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
C :: 1
B :: 0
A :: 1
B :: 0
C :: 1
B :: 0
A :: 1
B :: 0
C :: 1
D :: 0
A :: 1
B :: 0
C :: 1
D :: 0
A :: 1
B :: 0
C :: 1
D :: 0
A :: 1
D :: 0
C :: 1
D :: 0
A :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0

2.2、Lock通信示例：

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

/**
 * 线程通信的例子:有2个线程实现对一个初始值是0的变量
 * 		一个线程对值+1、一个线程对值-1
 * 		A线程  1 			B线程  0 
 * 		A线程  1 			B线程  0 
 * 		A线程  1 			B线程  0 
 * 		....
 */
class Share{
	
	private final Lock lock = new ReentrantLock();
	private final Condition condition  = lock.newCondition(); 

	
	//初始值
	private int number = 0;
	//+1方法
	public void add() throws InterruptedException {
		lock.lock();
		try {
			while (number != 0) {//number不是0，等待
				condition.await();
			}
			number++;//number值是0就+1
			System.out.println(Thread.currentThread().getName() + " :: " + number);
			condition.signalAll();
		} finally {
			lock.unlock();
		}
	}
	//-1方法
	public void subtract() throws InterruptedException {
		lock.lock();
		try {
			while (number != 1) {//number不是1，等待
				condition.await();
			}
			number--;//number值是1就-1
			System.out.println(Thread.currentThread().getName() + " :: " + number);
			condition.signalAll();
		} finally {
			lock.unlock();
		}
	}
	
}

public class ThreadDemo2 {

	public static void main(String[] args) {
		Share share = new Share();
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.add();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"A").start();
		
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.subtract();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"B").start();
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.add();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"C").start();
		
		new Thread(()-> {
			for (int i = 0; i <= 10; i++) {
				try {
					share.subtract();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"D").start();
	}
	
}

结果：

A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
A :: 1
B :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0
C :: 1
D :: 0

2.3、线程间定制化通信

线程A输出2次，线程B输出3次，线程C输出5次这种例子，相当于定制版通信

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

/**
 * 线程间定制化通信的例子:
 * 有3个线程，按照如下进行打印
 * A线程  打印2次 	B线程  打印3次  C线程  打印5次 
 * A线程  打印2次 	B线程  打印3次  C线程  打印5次 
 * A线程  打印2次 	B线程  打印3次  C线程  打印5次 
 * 		....
 * 打印5轮
 */
class ShareResource{
	
	private int flag = 1;//1:A、2:B、3:C
	
	private final Lock lock = new ReentrantLock();
	private final Condition c1  = lock.newCondition(); 
	private final Condition c2  = lock.newCondition(); 
	private final Condition c3  = lock.newCondition(); 
	
	//打印2次
	public void print2(int loop) throws InterruptedException {
		lock.lock();
		try {
			while (flag != 1) {//flag不是1，等待
				c1.await();
			}
			for (int i = 1; i <=2; i++) {
				System.out.println(Thread.currentThread().getName() + " :: "+ i +" 轮数:"+ loop);
			}
			flag=2;
			c2.signal();
		} finally {
			lock.unlock();
		}
	}
	//打印3次
	public void print3(int loop) throws InterruptedException {
		lock.lock();
		try {
			while (flag != 2) {//flag不是2，等待
				c2.await();
			}
			for (int i = 1; i <=3; i++) {
				System.out.println(Thread.currentThread().getName() + " :: "+ i +" 轮数:"+ loop);
			}
			flag=3;
			c3.signal();
		} finally {
			lock.unlock();
		}
	}
	//打印5次
	public void print5(int loop) throws InterruptedException {
		lock.lock();
		try {
			while (flag != 3) {//flag不是3，等待
				c3.await();
			}
			for (int i = 1; i <=5; i++) {
				System.out.println(Thread.currentThread().getName() + " :: "+ i +" 轮数:"+ loop);
			}
			flag=1;
			c1.signal();
		} finally {
			lock.unlock();
		}
	}
}
public class ThreadDemo3 {

	public static void main(String[] args) {
		ShareResource share = new ShareResource();
		new Thread(()-> {
			for (int i = 1; i <= 5; i++) {
				try {
					share.print2(i);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"A").start();
		new Thread(()-> {
			for (int i = 1; i <= 5; i++) {
				try {
					share.print3(i);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"B").start();
		new Thread(()-> {
			for (int i = 1; i <= 5; i++) {
				try {
					share.print5(i);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"C").start();
	}
}

结果：

A :: 1 轮数:1
A :: 2 轮数:1
B :: 1 轮数:1
B :: 2 轮数:1
B :: 3 轮数:1
C :: 1 轮数:1
C :: 2 轮数:1
C :: 3 轮数:1
C :: 4 轮数:1
C :: 5 轮数:1
A :: 1 轮数:2
A :: 2 轮数:2
B :: 1 轮数:2
B :: 2 轮数:2
B :: 3 轮数:2
C :: 1 轮数:2
C :: 2 轮数:2
C :: 3 轮数:2
C :: 4 轮数:2
C :: 5 轮数:2
A :: 1 轮数:3
A :: 2 轮数:3
B :: 1 轮数:3
B :: 2 轮数:3
B :: 3 轮数:3
C :: 1 轮数:3
C :: 2 轮数:3
C :: 3 轮数:3
C :: 4 轮数:3
C :: 5 轮数:3
A :: 1 轮数:4
A :: 2 轮数:4
B :: 1 轮数:4
B :: 2 轮数:4
B :: 3 轮数:4
C :: 1 轮数:4
C :: 2 轮数:4
C :: 3 轮数:4
C :: 4 轮数:4
C :: 5 轮数:4
A :: 1 轮数:5
A :: 2 轮数:5
B :: 1 轮数:5
B :: 2 轮数:5
B :: 3 轮数:5
C :: 1 轮数:5
C :: 2 轮数:5
C :: 3 轮数:5
C :: 4 轮数:5
C :: 5 轮数:5

3、集合的线程安全

3.1、List集合线程不安全示例

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class ThreadDemo4 {

	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		for (int i = 0; i < 20; i++) {
			new Thread(()->{
				list.add(UUID.randomUUID().toString().substring(0, 4));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}

执行会发生异常：java.util.ConcurrentModificationException

导致原因：

    并发争抢修改导致，一个人正在写入，另外一个人过来抢夺，导致数据不一致异常，并发修改异常。

解决方式：

    1、Vector

    2、Collections

    3、CopyOnWriteArrayList

1、Vector示例：
import java.util.*;

public class ThreadDemo4 {

	public static void main(String[] args) {
		List<String> list = new Vector<>();
		for (int i = 0; i < 20; i++) {
			new Thread(()->{
				list.add(UUID.randomUUID().toString().substring(0, 4));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}
2、Collections示例：
import java.util.*;

public class ThreadDemo4 {

	public static void main(String[] args) {
		List<String> list = Collections.synchronizedList(new ArrayList<>());
		for (int i = 0; i < 20; i++) {
			new Thread(()->{
				list.add(UUID.randomUUID().toString().substring(0, 4));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}
3、CopyOnWriteArrayList示例：
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class ThreadDemo4 {

	public static void main(String[] args) {
		List<String> list = new CopyOnWriteArrayList<>();
		for (int i = 0; i < 20; i++) {
			new Thread(()->{
				list.add(UUID.randomUUID().toString().substring(0, 4));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}
4、CopyOnWriteArrayList源码原理：

    用到了写时复制技术。add()先加锁，并把原集合进行复制，不影响读操作。写完之后重新覆盖原集合，解锁。

写时复制：

        CopyOnWrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器Object[]添加，而是先将当前容器Object[]进行Copy，复制出一个新的容器Object[] newElements，然后往新的容器Object[] newElements 里添加元素，添加完元素之后，再将原容器的引用指向新的容器setArray(newElements);这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
...
    final transient ReentrantLock lock = new ReentrantLock();
    private transient volatile Object[] array;
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
    final void setArray(Object[] a) {
        array = a;
    }
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

3.2、HashSet线程不安全演示

import java.util.*;

public class ThreadDemo4 {

	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		for (int i = 0; i < 20; i++) {
			new Thread(()->{
				set.add(UUID.randomUUID().toString().substring(0, 4));
				System.out.println(set);
			},String.valueOf(i)).start();
		}
	}
}

执行会发生异常：java.util.ConcurrentModificationException

解决方式：

    1、CopyOnWriteArraySet

    2、Collections.synchronizedSet(new HashSet<>());

1、CopyOnWriteArraySet示例：
import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

public class ThreadDemo4 {

	public static void main(String[] args) {
		Set<String> set = new CopyOnWriteArraySet<>();
		for (int i = 0; i < 20; i++) {
			new Thread(()->{
				set.add(UUID.randomUUID().toString().substring(0, 4));
				System.out.println(set);
			},String.valueOf(i)).start();
		}
	}
}

CopyOnWriteArraySet底层还是CopyOnWriteArrayList

public class CopyOnWriteArraySet<E> extends AbstractSet<E>
        implements java.io.Serializable {
...
    private final CopyOnWriteArrayList<E> al;

    /**
     * Creates an empty set.
     */
    public CopyOnWriteArraySet() {
        al = new CopyOnWriteArrayList<E>();
    }
...
}

3.3、HashMap线程不安全演示

import java.util.*;

public class ThreadDemo4 {

	public static void main(String[] args) {
		Map<String,String> map = new HashMap<>();
		for (int i = 0; i < 20; i++) {
			String key = String.valueOf(i);
			new Thread(()->{
				map.put(key,UUID.randomUUID().toString().substring(0, 4));
				System.out.println(map);
			},String.valueOf(i)).start();
		}
	}
}

执行会发生异常：java.util.ConcurrentModificationException

解决方式：

    1、ConcurrentHashMap

    2、Collections.synchronizedMap(new HashMap<>());

1、ConcurrentHashMap示例：
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class ThreadDemo4 {

	public static void main(String[] args) {
		Map<String,String> map = new ConcurrentHashMap<>();
		for (int i = 0; i < 20; i++) {
			String key = String.valueOf(i);
			new Thread(()->{
				map.put(key,UUID.randomUUID().toString().substring(0, 4));
				System.out.println(map);
			},String.valueOf(i)).start();
		}
	}
}


Java 并发编程(二)-多线程锁分类

Java 多线程学习(一)

一个程序员最重要的能力是：写出高质量的代码！！
有道无术，术尚可求也，有术无道，止于术。
无论你是年轻还是年长，所有程序员都需要记住：时刻努力学习新技术，否则就会被时代抛弃！

杀神lwz
关注
专栏目录
CompletableFuture(异步编程详解)
weixin_49161209的博客
09-09 924
CompletableFuture 一、runAsync 1.1、runAsunc（一个Runnable接口） package com.thread.study.jdksyn; import java.util.concurrent.*; /** * @ClassName * @Description TODO * @Author ZQS * @Date 2020/9/9 0009 14:29 * @Version 1.0 **/ public class CompletableFuture
Java---JUC并发篇（多线程详细版）
mxy2404830的博客
12-12 372
Java---多线程 1. 并发基础（线程篇） 1.1 java线程状态及线程状态之间的转化 1.2 操作系统层面有5种状态 2. 线程池的核心参数（7个核心参数） 3. sleep与wait方法对比 4. lock锁与synchronized锁区别 5. volatile 能否保证线程安全 6. Java中的悲观锁与乐观锁 6.1 悲观锁与乐观锁区别 6.2.2 悲观锁与乐观锁代码实现共享变量线程安全 7. Hashtable 与 ConcurrentHashMa
JUC并发编程2（共享模型之管程）
cygqtt的博客
11-08 100
要点与前面的保护性暂停中的 GuardObject 不同，不需要产生结果和消费结果的线程一一对应消费队列可以用来平衡生产和消费的线程资源生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据JDK 中各种阻塞队列，采用的就是这种模式。
JAVA底层JVM（一）
最新发布
qq_43875617的博客
07-20 906
支持公平/非公平策略支持可重入同一读线程在获取了读锁后还可以获取读锁同一写线程在获取了写锁之后既可以再次获取写锁又可以获取读锁同一读线程在获取了读锁后不可以获取写锁支持锁降级，不支持锁升级读写锁如果使用不当，很容易产生“饥饿”问题：在读线程非常多，写线程很少的情况下，很容易导致写线程“饥饿”，虽然使用“公平”策略可以一定程度上缓解这个问题，但是“公平”策略是以牺牲系统吞吐量为代价的。
Java并发编程（JUC）
weixin_43872993的博客
04-19 3810
1、Java并发编程——线程之间高效协作 2、了解JUC基本原理，了解各种锁的机制，避免死锁
JAVA并发编程（JUC）
byteyoung
08-22 419
java.util.concurrent 并发编程中使用的工具类 java.util.concurrent.atomic java.util.concurrent.locks 1.进程/线程？ 进程：和操作系统有关系，后台运行的一个程序就是进程 线程：轻量级的进程 容灾备份线程，文字检查线程，QQ内在线传文件，在线聊天 2.并发/并行 多个线程同一时间点争取同一资源 并发：同⼀时间段，多个任务都在执⾏(单位时间内不⼀定同时执⾏)； 并⾏：单位时间内，多个任务同时执⾏。 你...
java之彻底搞懂并发编程、juc
liyu1012的博客
12-08 385
`## 并发编程 1. 什么是juc java.util.concurrent在并发编程中使用的工具类 2. 线程基础 2.1 进程和线程 进程 一个程序,QQ.exe 一个进程往往可以包含多个线程 java有多个线程? 2个 main GC 线程 比如安全管家是一个进程,那么杀毒、垃圾清理都是一个线程 2.2 并发和并行 Erlang 之父 Joe Armstrong 用一张5岁小孩都能看懂的图解释了并发与并行的区别 并发是两个队列交替使用一台咖啡机 并行是两个队列同时使用两台咖
java并发编程专题（六）----浅析（JUC）Semaphore
08-18
Java 并发编程专题（六）----浅析（JUC）Semaphore 是 Java 并发编程中的一种重要机制，它主要用于控制多个线程访问共享资源的同时性。Semaphore 是一种信号量机制，它维护了一个许可集，通过 acquire() 和 release...
java并发编程-AQS和JUC实战
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
Java并发编程-3.pdf
05-28
Java并发编程中的多线程协作机制 在 Java 并发编程中，多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中，多个线程之间如何协作、同步和通信，以达到共同完成某个任务的目的。Java 提供了多种...
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
Java并发编程中的ReentrantLock是Java并发包（java.util.concurrent，简称JUC）中的一个重要的锁机制，它是Lock接口的一个具体实现，提供了比synchronized更强大的锁定功能和更细粒度的控制。ReentrantLock的主要...
java并发编程专题（九）----（JUC）浅析CyclicBarrier
08-18
Java 并发编程专题（九）----（JUC）浅析 CyclicBarrier CyclicBarrier 是 Java 并发编程中的一个同步辅助工具，它允许一组线程全部等待彼此到达公共屏障点。它的字面意思是可循环使用的屏障，用于让一组线程到达一...
java 高并发编程（JUC）[狂神笔记+整理]
weixin_45447134的博客
12-08 1135
文章目录1.juc 编程2.进程和线程3.Lock锁（重点）4.生产者和消费者模式问题5. 八锁现象6.集合类不安全7.Callable(实现多线程的第三种方式)8.常用辅助类(高并发必会)8.1 .CountDownLatch 减法计数器8.2.CyclicBarrier 加法计数器 (栅栏，循环屏障)8.3 Semaphore 信号量；9.读写锁 ReadWriteLock10.BlockingQueue 阻塞队列SynchronousQueue 同步队列11.线程池（重点）自定义线程池如何设置线
JAVA笔记 | JUC并发编程
qq_37630282的博客
02-09 525
JUC学习笔记
java 并发 JUC 一
zhouyanqingbfq的博客
06-25 387
J.U.C（java.util.concurrent）简介 java在1.5之后推出了一套新的处理并发的机制，提高了java在多线程方面执行的效率。 J.U.C 作为java新的并发处理机制，大量加入了非阻塞同步， 图一 ...
Java基础之JUC-高并发编程知识点大全
weixin_50419456的博客
04-25 382
JUC-高并发编程 1、JUC介绍 JUC简介 JUC就是 java.util .concurrent 工具包的简称。-处理线程的工具包 进程和线程的概念 进程与线程 进程 是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程— —资源分配的最小单位。 线程 是操作系统能够进行运算调度的最小单位。 系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。 线程的状
【java 高并发编程之JUC】2w字带你JUC从入门到精通
热门推荐
LoveSummer
02-16 5万+
wait()是让获得对象锁的线程实现等待，会自动释放当前线程占有的对象锁。每个对象（Object）都拥有对象锁，既然要释放当前线程占有的对象锁并让其进入 WAITING 状态，自然是要操作对应的对象（Object）而非当前的线程（Thread为什么sleep()方法定义在Thread中？因为sleep()是让当前线程暂停执行，不涉及到对象类，也不需要获得对象锁。java JUC 中 Object里wait()、notify() 实现原理及实战讲解。
【狂神Java笔记】JUC并发（附代码）（更新中……）
Blue
02-26 1096
目录JUC并发1、什么是JUC？2、线程和进程并发、并行线程有几个状态：wait / sleep区别3、Lock锁(重点)传统 SynchronizedLock锁Synchronized和Lock区别锁是什么,如何判断锁得是谁！4、生产者和消费者问题Synchronized版JUC版5、8锁现象代码Text 1Text 2Text 3Text 4小结6、集合类不安全list 不安全set 不安全map 不安全7、callable （简单） JUC并发 1、什么是JUC？ java.util 工具包、
JAVA进阶JUC并发编程（一）
qq_44186810的博客
10-28 210
进阶JUC JUC是与属于三个包 java.util.concurrent java.util.concurrent.atomic java.util.concurrentlocks 回顾知识 线程和进程 进程：一个程序。例子：QQ.exe程序的集合。 线程：作为独立运行和独立调度的基本单位。例子：开一个进程Typora,写字，保存（线程负责） 补： 一个进程往往可以包含多个线程，至少包含一个！ 线程就是一个单独的资源类，没有任何附属的操作！ Java默认有2个线程，是main/GC(垃圾回收) j
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杀神lwz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值