目录
2、测试：get()方法是等到上面的线程执行完，有了结果以后才执行的。
一、Java JUC 简介
在Java 5.0 提供了java.util.concurrent（简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection 实现等。
二、volatile 关键字-内存可见性
1、概念：内存可见性
- 内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。
- 可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能实时地看到其他线程写入的值，有时甚至是根本不可能的事情。
- 我们可以通过同步来保证对象被安全地发布。除此之外我们也可以使用一种更加轻量级的volatile 变量。
2、问题描述：
- 这里有两个线程，一个main线程，一个ThreadDemo线程；
- main启动后，又启动了ThreadDemo；
- ThreadDemo先睡了一会，再把flag的值由false改为true；
- main读到flag的值，继续进行操作。
public class TestVolatile {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
new Thread(td).start();
while (true) {
if (td.isFlag()) {
System.out.println("------------------");
break;
}
}
}
}
class ThreadDemo implements Runnable {
private boolean flag = false;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
flag = true;
System.out.println("flag=" + isFlag());
}
public boolean isFlag() {
return flag;
}
}3、结果：
ThreadDemo线程中的flag是true，而main线程读到的flag是false。main不断重试，程序无法结束。
4、分析：
- 程序启动后，ThreadDemo和main都读取了主存中flag的值false，放到各自的工作内存中；
- ThreadDemo醒后，将flag的值改为true，又写回到主存中；
- main使用while在循环时，一直使用的自己工作内存中的值（while执行的速度太快了，没有机会去主存中读值了），没有察觉到主存中的值已经改变，所以一直循环。
原因：两个线程在操作共享数据时，对共享数据的操作是彼此不可见的
解决1：同步锁（synchronized）解决
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
new Thread(td).start();
while (true) {
synchronized (td) {
if (td.isFlag()) {
System.out.println("------------------");
break;
}
}
}
}
正常结束！
缺点：效率低，多线程下，还需要判断是否获得锁，若前一个线程获得锁，则后面的线程阻塞。
解决2：volatile 关键字：多线程操作数据时，保证内存中数据的可见性。（结果同上，正常结束！）
private volatile boolean flag = false;问题：是否可用 volatile 替代 synchronized 呢？ 不能。volatile 相较于 synchronized 是一种较为轻量级的同步策略；volatile 不具备“互斥性”；volatile 不能保证变量的“原子性”。
三、原子变量-CAS算法
1、概念：原子变量
- 类的小工具包，支持在单个变量上解除锁的线程安全编程。
- 事实上，此包中的类可将volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。
- 类AtomicBoolean、AtomicInteger、AtomicLong 和AtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。
- AtomicIntegerArray、AtomicLongArray 和AtomicReferenceArray 类进一步扩展了原子操作，对这些类型的数组提供了支持。这些类在为其数组元素提供volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。
- 核心方法：boolean compareAndSet(expectedValue, updateValue)。
- java.util.concurrent.atomic 包下提供了一些原子操作的常用类:AtomicBoolean 、AtomicInteger 、AtomicLong 、AtomicReference；AtomicIntegerArray 、AtomicLongArray；AtomicMarkableReference；AtomicReferenceArray；AtomicStampedReference。
2、问题：i++的原子性问题
i++的操作实际上分为三个步骤“读-改-写”，eg：int temp = i; i = i + 1; i = temp;
public class TestAtomicDemo {
public static void main(String[] args) {
AtomicDemo ad = new AtomicDemo();
for (int i = 0; i < 30; i++) {
new Thread(ad).start();
}
}
}
class AtomicDemo implements Runnable{
private int serialNumber = 0;
@Override
public void run() {
try { Thread.sleep(200); } catch (InterruptedException e) {}
System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
}
public int getSerialNumber(){ return serialNumber++; }
}3、结果：出现并发问题。
4、分析：
- 假如主存中的sn=0，现在有两个线程进来读数据；
- 假设线程A先读数据，进行sn++操作；
- 在线程A打算将结果写入主存时，线程B读到了主存的数据sn=0；
- 线程A将结果写入主存，并输出sn=1；
- 而线程B也是进行相同操作，将结果sn=1写入主存并输出。
问题：这似乎是内存可见性的问题？？？好的，假设这是可见性问题，那么我们加上 volatile 关键字，就相当于线程A读取主存数据并修改，准备写入主存时，线程B读数据并修改，依然还是会出现这种问题。所以说 volatile 不能解决此类问题。那么这个问题产生的原因是什么？是因为i++这个操作实际上是三步操作，而并非一步。而 volatile 只能保证可见性，不能保证原子性。在这个情况下，即便是使用 volatile ，内存可见性问题，依然存在，因为这是非原子性捣的鬼，超出了 volatile 的能力范围。
解决：原子变量
在 java.util.concurrent.atomic 包下提供了一些原子变量。1. volatile 保证内存可见性；2. CAS（Compare-And-Swap） 算法保证数据变量的原子性。CAS 算法是硬件对于并发操作的支持，CAS 包含了三个操作数：①内存值 V；②预估值 A；③更新值 B，当且仅当 V == A 时， V = B; 否则，不会执行任何操作。CAS 保证了原子性，因为失败后并不会阻塞，效率比一般的同步锁效率高，只是自己写的东西稍微多点儿。
class AtomicDemo implements Runnable{
// private int serialNumber = 0;
private AtomicInteger serialNumber = new AtomicInteger(0);
@Override
public void run() {
try { Thread.sleep(200); } catch (InterruptedException e) {}
System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
}
public int getSerialNumber(){ return serialNumber.getAndIncrement(); }
}5、模拟CAS算法
public class TestCompareAndSwap {
public static void main(String[] args) {
final CompareAndSwap cas = new CompareAndSwap();
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
int expectedValue = cas.get();
boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
System.out.println(b);
}
}).start();
}
}
}
class CompareAndSwap{
private int value;
//获取内存值
public synchronized int get(){ return value; }
//比较
public synchronized int compareAndSwap(int expectedValue, int newValue){
int oldValue = value;
if(oldValue == expectedValue){ this.value = newValue; }
return oldValue;
}
//设置
public synchronized boolean compareAndSet(int expectedValue, int newValue){
return expectedValue == compareAndSwap(expectedValue, newValue);
}
}结果：
四、ConcurrentHashMap 锁分段机制
1.简介
- Java 5.0 在java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。
- ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对于多线程的操作，介于HashMap 与Hashtable 之间。
- 内部采用“锁分段”机制替代Hashtable 的独占锁。进而提高性能。
- 此包还提供了设计用于多线程上下文中的Collection 实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和CopyOnWriteArraySet。
- 当期望许多线程访问一个给定collection 时，ConcurrentHashMap 通常优于同步的HashMap，ConcurrentSkipListMap 通常优于同步的TreeMap。
- 当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的ArrayList。
2、ConcurrentHashMap详解
3、CopyOnWriteArrayList测试
（1）并发、同步状态下的ArrayList出现的问题
public class TestCopyOnWriteArrayList {
public static void main(String[] args) {
HelloThread ht = new HelloThread();
for (int i = 0; i < 10; i++) { new Thread(ht).start(); }
}
}
class HelloThread implements Runnable{
private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
static{ list.add("AA"); list.add("BB"); list.add("CC"); }
@Override
public void run() {
Iterator<String> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
list.add("AA");
}
}
}迭代过程中进行修改时，报错如下（因底层读、写操作的是同一个数组）：
AA
Exception in thread "Thread-0" Exception in thread "Thread-1" AA
java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at test.HelloThread.run(TestCopyOnWriteArrayList.java:27)
at java.lang.Thread.run(Thread.java:748)
java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at test.HelloThread.run(TestCopyOnWriteArrayList.java:27)
at java.lang.Thread.run(Thread.java:748)
......（2）使用CopyOnWriteArrayList后，正常运行（读、写操作不是同一个数组）
//private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();看一下它的 add(E e) 源码：添加时先是 copy 一份新的数组进行 写 操作。这里加锁，若不加锁，则多线程环境下会 copy 出N个副本出来。注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。
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();
}
}五、CountDownLatch 闭锁
1、简介
Java 5.0 在java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行：确保某个计算在其需要的所有资源都被初始化之后才继续执行;确保某个服务在其依赖的所有其他服务都已经启动之后才启动;等待直到某个操作所有参与者都准备就绪再继续执行。
2、需求
统计5个线程并发执行的时间（eg:仓库中按商品类型，分别计算每种商品总和、销售量......，最后进行汇总）
3、设计
public class TestCountDownLatch {
public static void main(String[] args) {
LatchDemo ld = new LatchDemo();
long start = System.currentTimeMillis();
for (int i = 0; i < 5; i++) { new Thread(ld).start(); }
long end = System.currentTimeMillis();
System.out.println("耗费时间为： " + (end - start));
}
}
class LatchDemo implements Runnable {
@Override
public void run() {
for (int i = 0; i < 500; i++) {
if (i % 2 == 0) { System.out.println(i); }
}
}
}
4、结果
上述代码可以正常运行，但是结果看不到时间输出。这是因为主线程和子线程并发执行，计算不了子线程运行的时间，实际上我们希望的流程是先主线程获得当前时间，然后子线程运行，主线程等到子线程全部运行完毕，最后主线程再获得时间，计算出消耗的时间。
5、使用CountDownLatch
public class TestCountDownLatch {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(5);
LatchDemo ld = new LatchDemo(latch);
long start = System.currentTimeMillis();
for (int i = 0; i < 5; i++) { new Thread(ld).start(); }
try { latch.await(); } catch (InterruptedException e){}
long end = System.currentTimeMillis();
System.out.println("耗费时间为： " + (end - start));
}
}
class LatchDemo implements Runnable {
private CountDownLatch latch;
public LatchDemo(CountDownLatch latch) { this.latch = latch; }
@Override
public void run() {
try {
for (int i = 0; i < 50; i++) {
if (i % 2 == 0) { System.out.println(i); }
}
} finally {
//为保证 countDown 一定执行
latch.countDown();
}
}
}六、实现Callable 接口
1、简介
- Java 5.0 在java.util.concurrent 提供了一个新的创建执行线程的方式：Callable 接口。
- Callable 接口类似于Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是Runnable 不会返回结果，并且无法抛出经过检查的异常。
- Callable 需要依赖FutureTask ，FutureTask 也可以用作闭锁。
2、测试：get()方法是等到上面的线程执行完，有了结果以后才执行的。
public class TestCallable {
public static void main(String[] args) {
ThreadDemo1 td = new ThreadDemo1();
//1、执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果
FutureTask<Integer> result = new FutureTask<>(td);
new Thread(result).start();
//2、接收线程运算后的结果
try {
Integer sum = result.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
class ThreadDemo1 implements Callable<Integer> {
@Override
public Integer call() {
int sum = 0;
for (int i = 0; i <= 10; i++) {
System.out.println(i);
sum += i;
}
return sum;
}
}七、Lock 同步锁
1、简介
- 在Java 5.0 之前，协调共享对象的访问时可以使用的机制只有synchronized 和volatile 。
- Java 5.0 后增加了一些新的机制，但并不是一种替代内置锁的方法，而是当内置锁不适用时，作为一种可选择的高级功能。ReentrantLock 实现了Lock 接口，并提供了与synchronized 相同的互斥性和内存可见性。
- 但相较于synchronized 提供了更高的处理锁的灵活性。
- 显示锁，lock()加锁，unlock()解锁。
2、测试
public class TestLock {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(ticket, "1号窗口").start();
new Thread(ticket, "2号窗口").start();
new Thread(ticket, "3号窗口").start();
}
}
class Ticket implements Runnable{
private int tick = 100;
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
lock.lock();
try {
if (tick > 0){
try {
Thread.sleep(200);
} catch (Exception e){}
System.out.println(Thread.currentThread().getName() + " 完成售票，余票为：" + --tick);
}
} finally {
lock.unlock();
}
}
}
}
3、未使用-等待唤醒-机制的生产者消费者模式
public class TestProductorAndConsumer {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Productor pro = new Productor(clerk);
Consumer cus = new Consumer(clerk);
new Thread(pro, "生产者A").start();
new Thread(cus, "消费者B").start();
}
}
//电源
class Clerk {
private int product = 0;
//进货
public synchronized void get() {
if (product >= 5) { System.out.println("产品已满！");
} else {
System.out.println(Thread.currentThread().getName() + " : " + ++product);
}
}
//卖货
public synchronized void sale() {
if (product <= 0) { System.out.println("缺货！");
} else {
System.out.println(Thread.currentThread().getName() + " : " + --product);
}
}
}
//生产者
class Productor implements Runnable {
private Clerk clerk;
public Productor(Clerk clerk) { this.clerk = clerk; }
@Override
public void run() { for (int i = 0; i < 10; i++) { clerk.get(); } }
}
//消费者
class Consumer implements Runnable {
private Clerk clerk;
public Consumer(Clerk clerk) { this.clerk = clerk; }
@Override
public void run() { for (int i = 0; i < 10; i++) { clerk.sale(); } }
}结果：产生了过度生产和过度消费的问题。
解决：添加-等待唤醒-机制
class Clerk {
private int product = 0;
//进货
public synchronized void get() {
if (product >= 5) {
System.out.println("产品已满！");
try {
this.wait(); //等待消费者唤醒自己
} catch (InterruptedException e) {
}
} else {
System.out.println(Thread.currentThread().getName() + " : " + ++product);
this.notifyAll();//通知消费者继续消费
}
}
//卖货
public synchronized void sale() {
if (product <= 0) {
System.out.println("缺货！");
try {
this.wait();//等待生产者唤醒自己
} catch (InterruptedException e) {
}
} else {
System.out.println(Thread.currentThread().getName() + " : " + --product);
this.notifyAll();//通知生产者继续生产
}
}
}
改变：将 if(product >= 5) 中5改为1，再运行时，程序无法结束。
原因：
假设生产者只剩下2次生产的机会（一共5次），消费者剩下1次消费的机会。运行时，消费者抢到资源开始消费，假设此时product=0，应执行“缺货”，然后wait，停在这个位置，释放了锁的资源。（当再次获得资源时，是从wait这个位置继续执行，此时不会执行else中的代码，由于只剩下这1次机会，执行完后消费者线程停止。）生产者现在拿到资源，开始生产，现在product=0不满足if条件，于是执行++product使得product=1，然后notifyAll。此时生产者和消费者同时抢锁，现在消费者又抢到锁了，于是接着之前的wait执行代码，else无法执行，消费者线程结束。此时只剩生产者，而product=1，满足if条件，生产者wait。此时没有其他线程来唤醒消费者，所以程序无法结束。
解决：去掉else
//进货
public synchronized void get() {
if (product >= 1) {
System.out.println("产品已满！");
try {
this.wait(); //等待消费者唤醒自己
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : " + ++product);
this.notifyAll();//通知消费者继续消费
}
//卖货
public synchronized void sale() {
if (product <= 0) {
System.out.println("缺货！");
try {
this.wait();//等待生产者唤醒自己
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : " + --product);
this.notifyAll();//通知生产者继续生产
}之前是一个生产者、一个消费者，这样是没有问题的，那么现在再添加一个生产者、一个消费者，让他们去竞争，看看结果：
new Thread(pro, "生产者A").start();
new Thread(cus, "消费者B").start();
new Thread(pro, "生产者C").start();
new Thread(cus, "消费者D").start(); 
原因：
假设现在两个消费者抢资源，都想进入if判断，而现在product=0，此时只有一个消费者进if，然后它wait了，释放了锁。此时另一个消费者抢到锁，进入if，也wait了。紧接着生产者抢到资源，开始生产，并notifyAll，此时两个消费者都醒了，继续执行--product，于是出现负数。
解决：if 改为 while 即可
八、Condition 控制线程通信
1、简介
- Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个Lock 可能与多个Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的Object 版本中的不同。
- 在Condition 对象中，与wait、notify 和notifyAll 方法对应的分别是await、signal 和signalAll。
- Condition 实例实质上被绑定到一个锁上。要为特定Lock 实例获得Condition 实例，请使用其newCondition() 方法。
2、生产者消费者测试
public class TestProductorAndConsumerForLock {
public static void main(String[] args) {
Clerk1 clerk = new Clerk1();
Productor1 pro = new Productor1(clerk);
Consumer1 con = new Consumer1(clerk);
new Thread(pro, "生产者 A").start();
new Thread(con, "消费者 B").start();
}
}
class Clerk1 {
private int product = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
// 进货
public void get() {
lock.lock();
try {
if (product >= 1) {
System.out.println("产品已满!");
try {
condition.await();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + ":" +
++product);
condition.signalAll();
} finally {
lock.unlock();
}
}
//卖货
public void sale() {
lock.lock();
try {
if (product <= 0) {
System.out.println("缺货！");
try {
condition.await();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + ":" +
--product);
condition.signalAll();
} finally {
lock.unlock();
}
}
}
// 生产者
class Productor1 implements Runnable {
private Clerk1 clerk;
public Productor1(Clerk1 clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.get();
}
}
}
// 消费者
class Consumer1 implements Runnable {
private Clerk1 clerk;
public Consumer1(Clerk1 clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
clerk.sale();
}
}
}九、线程按序交替
1、要求
编写一个程序，开启3 个线程，这三个线程的ID 分别为A、B、C，每个线程将自己的ID 在屏幕上打印10 遍，要求输出的结果必须按顺序显示。如：ABCABCABC…… 依次递归。
2、测试
public class TestABCAlternate {
public static void main(String[] args) {
AlternateDemo demo = new AlternateDemo();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 4; i++) {
demo.loopA(i);
}
}
}, "A").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 4; i++) {
demo.loopB(i);
}
}
}, "B").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 4; i++) {
demo.loopC(i);
System.out.println("----------------");
}
}
}, "C").start();
}
}
class AlternateDemo {
//当前正在执行线程的标记
private int number = 1;
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
/**
* @param totalLoop 循环第几轮
*/
public void loopA(int totalLoop) {
lock.lock();
try {
//1.判断
if (number != 1) {
condition1.await();
}
//2.打印
for (int i = 1; i <= 1; i++) {
System.out.println(Thread.currentThread().getName() + "\t" +i + "\t" + totalLoop);
}
//3.唤醒
number = 2;
condition2.signal();
} catch (Exception e) {
} finally {
lock.unlock();
}
}
public void loopB(int totalLoop) {
lock.lock();
try {
if (number != 2) {
condition2.await();
}
for (int i = 1; i <= 1; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
}
number = 3;
condition3.signal();
} catch (Exception e) {
} finally {
lock.unlock();
}
}
public void loopC(int totalLoop) {
lock.lock();
try {
if (number != 3) {
condition3.await();
}
for (int i = 1; i <= 1; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
}
number = 1;
condition1.signal();
} catch (Exception e) {
} finally {
lock.unlock();
}
}
}十、ReadWriteLock 读写锁
1、简介
- ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有writer，读取锁可以由多个reader 线程同时保持。写入锁是独占的。
- ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作。
2、实例
public class TestReadWriteLock {
public static void main(String[] args) {
ReadWriteLockDemo rw = new ReadWriteLockDemo();
new Thread(new Runnable() {
@Override
public void run() {
rw.set((int)(Math.random() * 101));
}
}, "Write: ").start();
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
@Override
public void run() {
rw.get();
}
}).start();
}
}
}
class ReadWriteLockDemo {
private int number = 0;
private ReadWriteLock lock = new ReentrantReadWriteLock();
public void get() {
lock.readLock().lock();//加锁
try {
System.out.println(Thread.currentThread().getName() + " : " + number);
} finally {
lock.readLock().unlock();//解锁
}
}
public void set(int number) {
lock.writeLock().lock();//加锁
try {
System.out.println(Thread.currentThread().getName());
this.number = number;
} finally {
lock.writeLock().unlock();//解锁
}
}
}十一、线程八锁
- 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法
- 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
- 加个普通方法后发现和同步锁无关
- 换成两个对象后，不是同一把锁了，情况立刻变化。
- 都换成静态同步方法后，情况又变化
- 所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
- 所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！
十二、线程池
十三、线程调度
十四、ForkJoinPool 分支/合并框架工作窃取
