文章目录
使用Jitwatch工具
配置、启动过程
由于本节代码较多，在执行多线程代码之前，先学习使用Jitwatch工具，该工具可将java代码编译为汇编机器码，只有了解了机器底层最终是如何执行的，才能掌握多线程核心内容；
进入Jitwatch-master工具目录中，右键选择“Git GUI Here”
然后执行命令：mvn clean compile exec:java下载可视化工具
在JitWatch工具页面中点config配置.java和.class目录
收集java源码汇编日志：
-server -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -XX:+LogCompilation -XX:LogFile=jit.log
配置完后运行一下该java类，此时会在对应的目录下生成一个汇编语言的.log文件
点击JitWatch工具的Open Log，选择刚才生成的汇编日志
点击start运行Jitwatch
在该视图中对比Java代码和汇编代码（右边缺少汇编代码，说明配置有问题）
经检查发现如果运行当前.java时控制台报如下错误：
Could not load hsdis-amd64.dll; library not loadable; PrintAssembly is disabled
Java HotSpot(TM) 64-Bit Server VM warning: PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output
说明缺少一个“hsdis-amd64.dll”文件，下载地址;密码：deh4，然后将文件放到jdk目录下，如图所示：
此时再运行.java类，控制台输出如下汇编代码：
重新执行JitWatch工具，终于可以显示汇编代码：
Java中锁的概念
Lock的核心API
PS：根据Lock接口的源码注释，Lock接口的实现，具备和同步关键字同样的内存语义；
几种重要的锁实现方式：synchronized、ReentrantLock、ReentrantReadWriteLock
偏向锁到轻量级锁（状态的变化）
重量级锁 - 监视器（monitor）
ReentrantLock
ReentrantLock示例代码见线程安全的问题LockDemo3；
可重入锁代码示例：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
// ReentrantLock 可重入锁示例
public class ReentrantLockDemo1 {
private Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
ReentrantLockDemo1 demo1 = new ReentrantLockDemo1();
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
demo1.test(Thread.currentThread());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
Thread.sleep(500); // 等待0.5秒，让thread1先执行
thread2.start();
Thread.sleep(2000); // 两秒后，中断thread2
thread2.interrupt();
}
public void test(Thread thread) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "， 想获取锁");
// lock.lock(); //不推荐
lock.lockInterruptibly(); //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
try {
System.out.println(thread.getName() + "得到了锁");
Thread.sleep(10000); // 抢到锁，10秒不释放
} finally {
System.out.println(Thread.currentThread().getName() + "执行finally");
lock.unlock();
System.out.println(thread.getName() + "释放了锁");
}
}
}
lock.lock() 控制台输出：
Thread-0， 想获取锁
Thread-0得到了锁
Thread-1， 想获取锁
Thread-0执行finally
Thread-0释放了锁
Thread-1得到了锁
Thread-1执行finally
Thread-1释放了锁
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.study.lock.reentrantLock.ReentrantLockDemo1.test(ReentrantLockDemo1.java:38)
at com.study.lock.reentrantLock.ReentrantLockDemo1$1.run(ReentrantLockDemo1.java:16)
at java.lang.Thread.run(Thread.java:748)
lock.lockInterruptibly() 控制台输出：
Thread-0， 想获取锁
Thread-0得到了锁
Thread-1， 想获取锁
java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
at com.study.lock.reentrantLock.ReentrantLockDemo1.test(ReentrantLockDemo1.java:36)
at com.study.lock.reentrantLock.ReentrantLockDemo1$1.run(ReentrantLockDemo1.java:16)
at java.lang.Thread.run(Thread.java:748)
Thread-0执行finally
Thread-0释放了锁
读写锁ReadWriteLock
未使用读写锁代码示例：
// 不用读写锁
public class ReentrantReadWriteLockDemo1 {
public static void main(String[] args) {
final ReentrantReadWriteLockDemo1 readWriteLockDemo1 = new ReentrantReadWriteLockDemo1();
// 多线程同时读/写
new Thread(() -> {
readWriteLockDemo1.read(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockDemo1.write(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockDemo1.read(Thread.currentThread());
}).start();
}
// 不管读写，只有一个线程能用， 独享锁
public synchronized void read(Thread thread) { // 2秒
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName()+"正在进行“读”操作");
}
System.out.println(thread.getName()+"“读”操作完毕");
}
/** 写 */
public synchronized void write(Thread thread) {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName()+"正在进行“写”操作");
}
System.out.println(thread.getName()+"“写”操作完毕");
}
}
未使用读写锁，多个线程间读操作是串行执行的，最后执行写操作；
读写锁代码示例：
import java.util.concurrent.locks.ReentrantReadWriteLock;
// 读写锁（既保证了读数据的效率，也保证数据的一致性）
public class ReentrantReadWriteLockDemo2 {
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public static void main(String[] args) {
final ReentrantReadWriteLockDemo2 readWriteLockDemo2 = new ReentrantReadWriteLockDemo2();
// 多线程同时读/写
new Thread(() -> {
readWriteLockDemo2.read(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockDemo2.read(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockDemo2.write(Thread.currentThread());
}).start();
}
// 多线程读，共享锁
public void read(Thread thread) {
readWriteLock.readLock().lock();
try {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName() + "正在进行“读”操作");
}
System.out.println(thread.getName() + "“读”操作完毕");
} finally {
readWriteLock.readLock().unlock();
}
}
/**
* 写
*/
public void write(Thread thread) {
readWriteLock.writeLock().lock();
try {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName() + "正在进行“写”操作");
}
System.out.println(thread.getName() + "“写”操作完毕");
} finally {
readWriteLock.writeLock().unlock();
}
}
}
synchronized的概念
PS：同步关键字，不仅是实现同步，根据JVM规定还能保证可见性（读取最新内存数据，结束后写入主内存）；
synchronized加锁原理：
独享锁代码示例：
// 独享锁 方法(静态/非静态),代码块(对象/类)
public class ObjectSyncDemo1 {
static Object temp = new Object();
public void test1() {
synchronized (ObjectSyncDemo1.class) {
try {
System.out.println(Thread.currentThread() + " 我开始执行");
Thread.sleep(3000L);
System.out.println(Thread.currentThread() + " 我执行结束");
} catch (InterruptedException e) {
}
}
}
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
new ObjectSyncDemo1().test1();
}).start();
Thread.sleep(1000L); // 等1秒钟,让前一个线程启动起来
new Thread(() -> {
new ObjectSyncDemo1().test1();
}).start();
}
}
可重入锁代码示例：
// 可重入锁
public class ObjectSyncDemo2 {
public synchronized void test1(Object arg) {
System.out.println(Thread.currentThread() + " 我开始执行 " + arg);
if (arg == null) {
test1(new Object());
}
System.out.println(Thread.currentThread() + " 我执行结束" + arg);
}
public static void main(String[] args) throws InterruptedException {
new ObjectSyncDemo2().test1(null);
}
}
锁粗化代码示例：
// 锁粗化(运行时 jit 编译优化)
// jit 编译后的汇编内容, jitwatch可视化工具进行查看
public class ObjectSyncDemo3 {
int i;
public void test1(Object arg) {
synchronized (this) {
i++;
}
synchronized (this) {
i++;
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10000000; i++) {
new ObjectSyncDemo3().test1("a");
}
}
}
锁消除代码示例：
// 锁消除(jit)
public class ObjectSyncDemo4 {
public void test3(Object arg) {
StringBuilder builder = new StringBuilder();
builder.append("a");
builder.append(arg);
builder.append("c");
System.out.println(arg.toString());
}
public void test2(Object arg) {
String a = "a";
String c = "c";
System.out.println(a + arg + c);
}
public void test1(Object arg) {
// jit 优化, 消除了锁
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("a");
stringBuffer.append(arg);
stringBuffer.append("c");
System.out.println(stringBuffer.toString());
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 1000000; i++) {
new ObjectSyncDemo4().test1("123");
}
}
}
使用读写锁后，多个线程间读操作是并行的，最后执行写操作；
改造线程安全的HashMap代码示例：
对比过HashMap与HashTable可以知道，HashMap效率高，但却不是线程安全的，如果既要高效率，又想实现HashTable线程安全的特点，以下是改造HashMap的方法；
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
// 将hashmap改造一个并发安全的
// 比hashTable的实现，效率高，读取的适合并不会同步执行
public class MapDemo {
private final Map<String, Object> m = new HashMap<>();
private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private final Lock r = rwl.readLock();
private final Lock w = rwl.writeLock();
public Object get(String key) {
r.lock(); // 可以同时多个线程获取这把锁
try {
return m.get(key);
} finally {
r.unlock();
}
}
public Object[] allKeys() {
r.lock();
try {
return m.keySet().toArray();
} finally {
r.unlock();
}
}
public Object put(String key, Object value) {
w.lock(); // 一个线程获取 这把锁
try {
return m.put(key, value);
} finally {
w.unlock();
}
}
public void clear() {
w.lock();
try {
m.clear();
} finally {
w.unlock();
}
}
}
有关读写锁实际应用，缓存示例代码：
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
// 缓存示例
public class CacheDataDemo {
// 创建一个map用于缓存
private Map<String, Object> map = new HashMap<>();
private static ReadWriteLock rwl = new ReentrantReadWriteLock();
public static void main(String[] args) {
// 1 读取缓存里面的数据
// cache.query()
// 2 如果换成没数据,则取数据库里面查询 database.query()
// 3 查询完成之后,数据塞到塞到缓存里面 cache.put(data)
}
public Object get(String id) {
Object value = null;
// 首先开启读锁，从缓存中去取
rwl.readLock().lock();
try {
if (map.get(id) == null) {
// TODO database.query(); 全部查询数据库 ,缓存雪崩
// 必须释放读锁
rwl.readLock().unlock();
// 如果缓存中没有释放读锁，上写锁。如果不加锁，所有请求全部去查询数据库，就崩溃了
rwl.writeLock().lock(); // 所有线程在此处等待 1000 1 999 (在同步代码里面再次检查是否缓存)
try {
// 双重检查，防止已经有线程改变了当前的值，从而出现重复处理的情况
if (map.get(id) == null) {
// TODO value = ...如果缓存没有，就去数据库里面读取
}
rwl.readLock().lock(); // 加读锁降级写锁,这样就不会有其他线程能够改这个值，保证了数据一致性
} finally {
rwl.writeLock().unlock(); // 释放写锁@
}
}
} finally {
rwl.readLock().unlock();
}
return value;
}
}
该代码仅供参考，是缓存机制的思路，不可用；
Condition机制概念
condition 实现队列线程安全代码示例：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
// condition 实现队列线程安全。
public class QueueDemo {
final Lock lock = new ReentrantLock();
// 指定条件的等待 - 等待有空位
final Condition notFull = lock.newCondition();
// 指定条件的等待 - 等待不为空
final Condition notEmpty = lock.newCondition();
// 定义数组存储数据
final Object[] items = new Object[100];
int putptr, takeptr, count;
// 写入数据的线程,写入进来
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length) { // 数据写满了
notFull.await(); // 写入数据的线程,进入阻塞
}
items[putptr] = x;
if (++putptr == items.length) {
putptr = 0;
}
++count;
notEmpty.signal(); // 唤醒指定的读取线程
} finally {
lock.unlock();
}
}
// 读取数据的线程,调用take
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0) {
notEmpty.await(); // 线程阻塞在这里,等待被唤醒
}
Object x = items[takeptr];
if (++takeptr == items.length) {
takeptr = 0;
}
--count;
notFull.signal(); // 通知写入数据的线程,告诉他们取走了数据,继续写入
return x;
} finally {
lock.unlock();
}
}
}
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
