qq_42732184的博客

线程a是捣乱线程，将2改为3，又将3改回了2。这里使用带时间戳的原子引用（给数据增加版本号标识），每次修改了数据之后，会对数据的版本号进行加一操作。线程a通过两次修改，最终结果仍然是2，但是它中间是动了数据，由于每次修改数据完毕都会将数据的版本号加一，那么在b线程准备提交修改的数据时（将2改为3），虽然比对的数据是2，但是这个2不是原来的2，数据的版本号已经不是最初它拿到的版本号（这两个2的版本号不一样），说明这个数据中间被动了，所以b线程的修改不成功，会返回false。package com.han

package com.han.demo01;public class TestLazyMan { public static void main(String[] args) { for (int i = 0; i < 10; i++) { new Thread(() -> { LazyMan.getInstance(); }).start(); } }}c

优化资源的使用 -->池化技术线程池、连接池、内存池、对象池。。。（创建和销毁十分浪费资源）池化技术：事先贮备好一些资源，要用，就来这里拿，用完之后还回来线程池的好处：降低资源的消耗提高的响应速度方便管理线程复用，可以控制最大并发数、管理线程一、三大方法1、newSingleThreadExecutor() 单个线程package com.han.demo01;import java.util.concurrent.ExecutorService;import java.uti

package com.han.demo01;import java.util.HashMap;import java.util.Map;import java.util.concurrent.locks.ReadWriteLock;import java.util.concurrent.locks.ReentrantReadWriteLock;/** * 独占锁（写锁）:一次只能被一个线程占有 * 共享锁（读锁）:多个线程可以同时占有 * ReadWriteLock * 读-读 可以共

package com.han.demo01;import java.util.concurrent.Semaphore;import java.util.concurrent.TimeUnit;public class TestXHL { public static void main(String[] args) { Semaphore semaphore = new Semaphore(3);//单个参数为资源数量 for (int i = 1; i &

package com.han.demo01;import java.util.concurrent.BrokenBarrierException;import java.util.concurrent.CyclicBarrier;public class CB { public static void main(String[] args) { CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {//一旦

主要方法：countDown()、await()downLatch.countDown(); //数量-1downLatch.await();//等待计数器归零，然后再往下执行每次线程调用countDown()数量-1，假设计数器变成0，downLatch.await()就会被唤醒，继续执行！如果没有使用await方法，那么主线程其实是一直在跑的，所以还没等上面的六个线程跑完，主线程关门就已经输出了。package com.han.demo01;import java.util.concurre

package com.han.demo01;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class TestCondition { public static void main(String[] args) { Data02 data = n

1、获取lock锁对象2、通过lock锁对象创建Condition实例绑定到lock锁对象上3、上锁：lock.lock()4、try…catch执行业务5、finally中释放锁：lock.unlock()package com.han.demo01;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.Re

package com.han.demo01;public class TestPC { public static void main(String[] args) { Data data = new Data(); new Thread(() -> { for (int i = 0; i < 20; i++) { try { data.increment

synchronized（作为关键字）：package com.han.demo01;public class TestSaleTicket { public static void main(String[] args) { Ticket t = new Ticket(); new Thread(() -> { for (int i = 0; i < 60; i++) { t.sale();

解耦前：类SaleTicket与Runnable永远捆绑在了一起，它会变成一个线程类，而不是一个纯粹的类，不能很好体现OOP思想。package com.han.demo01;public class TestComparedSaleTicket { public static void main(String[] args) { SaleTicket st = new SaleTicket(); new Thread(st, "窗口1").start();