线程互斥(线程安全)
synchronized 简介
synchronized
是 Java 内建的同步机制,所以也有人称其为 Intrinsic Locking,它提供了互斥的语义和可见性,当一个线程已经获取当前锁时,其他试图获取的线程只能等待或者阻塞在那里synchronized
是 Java 中最为常用的同步方法之一,实现比较简单,代码简洁,可读性和维护性较好在JDK早期版本中,性能并不好,只适合锁竞争不是特别激烈的场合。目前随着JVM进步得到很好的优化,性能与重入锁(ReentrantLock)差距缩小(主要在于轻量锁的运用,如自旋锁、锁偏向等) JDK源码中 synchronized
的使用也有很多,如同步容器 Hashtable
, 同步包装器(Synchronized Wrapper),我们可以调用 Collections 工具类提供的包装方法,来获取一个同步的包装容器(如 Collections.synchronizedMap)但是它们都是利用非常粗粒度的同步方式,在高并发情况下,性能比较低下 更好的选择是使用并发包(JUC)提供的线程安全容器,这些容器基本是使用重入锁(ReentrantLock)实现,synchronized
和 ReentrantLock
的比较,见重入锁(ReentrantLock)博文
synchronized 用法
锁定对象:一定要同一个对象
synchronized
锁定非静态方法,这个等同于把方法全部语句用 synchronized
块包起来。一个方法建议一个 synchronized
,不然容易产生死锁
private synchronized void get(String name) {}
synchronized
锁定业务类对象。一般使用synchronized(this)
private void get2(String name) {
int len = name.length();
synchronized (this) {
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
synchronized
锁定同步块。相比较与锁定对象,锁定块更加精确,减少了锁范围,效率更高。
private void get3(String name) {
...
synchronized (name) {
}
...
}
锁类:锁定字节码
public synchronized static void get5(String name) {}
public static void get4(String name) {
int len = name.length();
synchronized (DataObject.class) {
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
线程同步(多线程复杂交互)
方法简介
synchronized
: 保证线程安全,线程互斥wait
: 可以让线程等待当前对象上的通知(notify
被调用),在wait
的过程中,线程会释放对象锁,供其他线程使用。当接收到对象上的通知后(notify
被调用),就能重新获取对象的独占锁,并且继续运行notify
:可以唤醒一个等待在当前对象上的线程。如果有多个线程等待,讲随机选择一个
示例代码
两个线程:子线程循环3次,主线程循环5次,然后子线程又循环3次,主线程5次,如此一共循环2次
synchronized
、wait
、notify
操作的必须是同一个对象
public class ThreadCommunication {
public static void main(String[] args) {
Data data = new Data();
new Thread(new MainThread(data), "thead 0 ").start();
new Thread(new SubThread(data), "thead 1 ").start();
}
/**
* 主线程
*/
static class MainThread implements Runnable {
private Data data;
public MainThread(Data data) {
this.data = data;
}
@Override
public void run() {
try {
for (int i = 0; i < 2; i++) {
data.mainMethod();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 子线程
*/
static class SubThread implements Runnable {
private Data data;
public SubThread(Data data) {
this.data = data;
}
@Override
public void run() {
try {
for (int i = 0; i < 2; i++) {
data.subMethod();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 业务对象
*/
static class Data {
/**
* 默认子线程运行
*/
private volatile boolean isSubRunnable = true;
synchronized void mainMethod() throws InterruptedException {
// 主线程先等待
while (isSubRunnable) {
this.wait();
}
for (int i = 0; i < 5; i++) {
System.out.println("Main线程运行次数 : " + i);
}
isSubRunnable = true;
this.notify();
}
synchronized void subMethod() throws InterruptedException {
// 一开始是true,先子线程运行
while (!isSubRunnable) {
this.wait();
}
for (int i = 0; i < 3; i++) {
System.out.println("Sub线程运行次数 : " + i);
}
isSubRunnable = false;
this.notify();//唤醒
}
}
}
线程同步: 简单实现一个阻塞队列
public class CustomBlockQueue {
private List<Object> list = new ArrayList<>();
public synchronized Object pop() throws InterruptedException {
// 如果队列为空,等待
while (list.isEmpty()) {
this.wait();
}
if (list.size() > 0) {
// 队列不为空,返回第一个对象
return list.remove(0);
} else {
return null;
}
}
public synchronized void put(Object object) {
// 添加到队列当中
list.add(object);
// 通知一个 pop()方法,可以取数据
this.notify();
}
}
synchronized 总结
代码简洁,线程安全,性能靠谱,功能没有 ReentrantLock
丰富 锁对象、锁代码块、锁class类三种用法 synchronized
加锁的方法之间也是互斥的(队列),原因在于锁定的是同一个对象只能保证线程安全,无法控制复杂逻辑的多线程交互,如需实现多线程交互,需要配合使用Object对象的 wait
、notify
方法
参考
源码地址