Java多线程编程总结
来源:互联网 发布:.cn域名可以过户吗? 编辑:程序博客网 时间:2024/06/06 06:40
Java并发编程
在 Java 5.0 提供了 java.util.concurrent (简称JUC )包,在此包中增加了在并发编程中很常用的实用工具类,用于定义类似于线程的自定义子系统,包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。
volatile
内存可见性
- 内存可见性(Memory Visibility)是指当某个线程正在使用对象状态而另一个线程在同时修改该状态,需要确保当一个线程修改了对象状态后,其他线程能够看到发生的状态变化。
- 可见性错误是指当读操作与写操作在不同的线程中执行时,我们无法确保执行读操作的线程能适时地看到其他线程写入的值,有时甚至是根本不可能的事情。
- 我们可以通过同步来保证对象被安全地发布。除此之外我们也可以使用一种更加轻量级的 volatile 变量。
volatile关键字
Java 提供了一种稍弱的同步机制,即 volatile 变量,用来确保将变量的更新操作通知到其他线程。
可以将 volatile 看做一个轻量级的锁,但是又与锁有些不同:
- 对于多线程,不是一种互斥关系
- 不能保证变量状态的“原子性操作”
/** * volatile关键字:当多个线程进行操作共享数据时,可以保证内存中数据可见. * 相较于synchronized是一种较为轻量级的同步策略. * volatile特点: * 1.volatile不具备互斥性 * 2.volatile不能保证变量的"原子性" */ public class TestVolatile { public static void main(String[] args) { ThreadDemo threadDemo = new ThreadDemo(); //启动线程 new Thread(threadDemo).start(); while (true) { // synchronized (threadDemo) { if (threadDemo.isFlag()) { System.out.println("main======"); break; } // } } } } class ThreadDemo extends Thread{ //标记 private volatile boolean flag = false; public void run(){ try { //线程睡眠 Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } //修改标记 flag = true; System.out.println(getName() + ": flag= " + isFlag()); } public boolean isFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } }
CAS算法
CAS 算法
CAS (Compare-And-Swap) 是一种硬件对并发的支持,针对多处理器操作而设计的处理器中的一种特殊指令,用于管理对共享数据的并发访问。
- CAS 是一种无锁的非阻塞算法的实现。
- CAS 包含了 3 个操作数:
- 需要读写的内存值 V
- 进行比较的值 A
- 拟写入的新值 B
- 当且仅当 V 的值等于 A 时,CAS 通过原子方式用新值 B 来更新 V 的值,否则不会执行任何操作。
原子变量
类的小工具包,支持在单个变量上解除锁的线程安全编程。事实上,此包中的类可将 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
/** * i++ 原子性问题: * i++ 操作分为三步骤:"读-改-写" * int temp = i; * i = i + 1; * i = temp; * * 原子变量:jdk1.5后java.util.concurrent.atomic 包下提供了常用的原子变量: * 1.volatile 保证内存可见性 * 2.CAS(Compare-And-Swap)算法保证数据的原子性, * CAS算法是硬件对于并发操作共享数据的支持 * CAS包含了三个操作数: * 内存值 V * 预估值 A * 更新值 B * 当且仅当 V == A 时,V = B,否则,将不进行任何操作 */ public class TestAtomicDemo { public static void main(String[] args) { AtomicDemo atomicDemo = new AtomicDemo(); //多个线程执行 for (int i = 0; i < 10; i++) { new Thread(atomicDemo).start(); } } } class AtomicDemo implements Runnable { // private int num = 0; private AtomicInteger num = new AtomicInteger(); @Override public void run() { try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " :" + getNum()); } public int getNum() { return num.getAndIncrement(); } }
ConcurrentHashMap 锁分段机制
- 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。
/** * CopyOnWriteArrayList/CopyOnWriteArraySet "写入复制" * 注意:添加操作多时,效率低,因为每次添加时都会进行复制,开销非常大. */ public class TestCopyOnWriterArrayList { public static void main(String[] args) { CurrentThread currentThread = new CurrentThread(); for (int i = 0; i < 10; i++) { new Thread(currentThread).start(); } } } class CurrentThread implements Runnable{ // private static List<String> list = Collections.synchronizedList(new ArrayList<String>()); private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(); static{ list.add("a"); list.add("b"); list.add("c"); } @Override public void run() { Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); list.add("m"); } } }
CountDownLatch 闭锁
- Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。
- CountDownLatch 一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
- 闭锁可以延迟线程的进度直到其到达终止状态,闭锁可以用来确保某些活动直到其他活动都完成才继续执行:
- 确保某个计算在其需要的所有资源都被初始化之后才继续执行;
- 确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
- 等待直到某个操作所有参与者都准备就绪再继续执行。
/** * CountDownLatch,闭锁:在完成某些运算时,只有其他所有线程的运算全部完成,当前运算才能继续执行 */ public class TestCountDownLatch { public static void main(String[] args) { CountDownLatch latch = new CountDownLatch(6); LatchDemo latchDemo = new LatchDemo(latch); long start = System.currentTimeMillis(); for (int i = 0; i < 6; i++) { new Thread(latchDemo).start(); } try { //等待 latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } 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() { synchronized (this) { try { for (int i = 0; i < 10000; i++) { if (i%2 == 1) { System.out.println(i); } } } finally { //减1 latch.countDown(); } } } }
实现 Callable 接口创建线程
- Java 5.0 在 java.util.concurrent 提供了一个新的创建执行线程的方式:Callable 接口
- Callable 接口类似于 Runnable,两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果,并且无法抛出经过检查的异常。
- Callable 需要依赖FutureTask ,FutureTask 也可以用作闭锁。
/** * 实现Callable接口创建执行线程,相较于实现Runnable接口的方式,方法有返回值,并且可以抛出异常 * 执行Callable方式,需要FutureTask实现类的支持,用于接收运算结果.FutureTask是Future的实现类. */ public class TestCallable { public static void main(String[] args) { CallableDemo cd = new CallableDemo(); //创建FutureTask,用于接收结果 FutureTask<Integer> result = new FutureTask<>(cd); //执行线程 new Thread(result).start(); try { //获取返回值,FutureTask可用于闭锁 Integer sum = result.get(); System.out.println("从0到100的总和是:"+sum); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } } } class CallableDemo implements Callable<Integer>{ @Override public Integer call() throws Exception { int sum = 0; for (int i = 0; i <= 100; i++) { System.out.println(i); sum += i; } return sum; } }
Lock 同步锁
- 在 Java 5.0 之前,协调共享对象的访问时可以使用的机制只有 synchronized 和 volatile 。Java 5.0 后增加了一些新的机制,但并不是一种替代内置锁的方法,而是当内置锁不适用时,作为一种可选择的高级功能。
- ReentrantLock 实现了 Lock 接口,并提供了与synchronized 相同的互斥性和内存可见性。但相较于synchronized 提供了更高的处理锁的灵活性。
/** * 用于解决多线程问题方式: * 1.同步代码块 * 2.同步方式 * 3.同步锁(jdk1.5之后) * Lock是一个显示锁,需要通过lock()方法上锁,必须通过unlock()方法进行释放锁. */ 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 ticket = 100; //lock锁 private Lock lock = new ReentrantLock(); @Override public void run() { //上锁 lock.lock(); try { while (true) { if (ticket > 0) { Thread.sleep(10); System.out.println(Thread.currentThread().getName() + "正在卖票,还剩" + --ticket + "张票"); } } } catch (InterruptedException e) { e.printStackTrace(); } finally{ //释放锁 lock.unlock(); } } }
Condition 控制线程通信
- Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似,但提供了更强大的功能。需要特别指出的是,单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题,Condition 方法的名称与对应的 Object 版本中的不同。
- 在 Condition 对象中,与 wait、notify 和 notifyAll 方法对应的分别是await、signal 和 signalAll。
- Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition 实例,请使用其 newCondition() 方法。
/** * 生产者和消费者 * 等待唤醒机制 * 虚假唤醒问题 * 使用Lock和Condition */ public class TestProductAndCustomerForLock { public static void main(String[] args) { Clerk clerk = new Clerk(); Product product = new Product(clerk); Consumer consumer = new Consumer(clerk); new Thread(product,"生产者A").start(); new Thread(consumer,"消费者B").start();; } } /** * 店员 */ class Clerk { private int product = 0; //新建锁 private Lock lock = new ReentrantLock(); //新建condition private Condition condition = lock.newCondition(); //进货 public void get(){ //上锁 lock.lock(); try { while (product >= 10) { //为了避免虚假唤醒问题,应该总是使用在循环中 System.out.println("产品已满!"); try { //等待 condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(Thread.currentThread().getName() + ":" + ++product); //唤醒 condition.signalAll(); } finally{ //释放锁 lock.unlock(); } } //卖货 public void sell(){ //上锁 lock.lock(); try { while (product <= 0) {//为了避免虚假唤醒问题,应该总是使用在循环中 System.out.println("缺货!"); try { //等待 condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(Thread.currentThread().getName() + ":"+ --product); //唤醒 condition.signalAll(); } finally{ //释放锁 lock.unlock(); } } } /** * 生产者 */ class Product implements Runnable{ private Clerk clerk; public Product(Clerk clerk) { this.clerk = clerk; } @Override public void run() { for (int i = 0; i < 20; i++) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //店员进货 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 < 20; i++) { //店员卖货 clerk.sell(); } } }
ReadWriteLock 读写锁
- ReadWriteLock 维护了一对相关的锁,一个用于只读操作,另一个用于写入操作。只要没有 writer,读取锁可以由多个 reader 线程同时保持。写入锁是独占的。。
- ReadWriteLock 读取操作通常不会改变共享资源,但执行写入操作时,必须独占方式来获取锁。对于读取操作占多数的数据结构。 ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构,其中包含的不变性可以完全不需要考虑加锁操作。
/** * ReadWriteLock:读写锁 * 写写/读写 需要"互斥" * 读读 不需要"互斥" */ public class TestReadWriteLock { public static void main(String[] args) { final ReadWriteLockDemo rwld = new ReadWriteLockDemo(); //写 new Thread(new Runnable() { @Override public void run() { rwld.write((int)Math.random()*101); } },"write : ").start(); //读 for (int i = 0; i < 100; i++) { new Thread(new Runnable() { @Override public void run() { rwld.read(); } },"read: ").start();; } } } class ReadWriteLockDemo { private int num = 0; //创建读写锁 private ReadWriteLock lock = new ReentrantReadWriteLock(); //读 public void read(){ //上锁 lock.readLock().lock(); try { System.out.println(Thread.currentThread().getName()+":"+num); } finally{ //释放锁 lock.readLock().unlock(); } } //写 public void write(int num){ //上锁 lock.writeLock().lock(); try { System.out.println(Thread.currentThread().getName() + ":" + num); this.num = num; } finally{ //释放锁 lock.writeLock().unlock(); } } }
线程池Executor
- 第四种获取线程的方法:线程池,一个 ExecutorService,它使用可能的几个池线程之一执行每个提交的任务,通常使用 Executors 工厂方法配置。
- 线程池可以解决两个不同问题:由于减少了每个任务调用的开销,它们通常可以在执行大量异步任务时提供增强的性能,并且还可以提供绑定和管理资源(包括执行任务集时使用的线程)的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据,如完成的任务数。
- 为了便于跨大量上下文使用,此类提供了很多可调整的参数和扩展钩子 (hook)。但
是,强烈建议程序员使用较为方便的 Executors 工厂方法 :- Executors.newCachedThreadPool()(无界线程池,可以进行自动线程回收)
- Executors.newFixedThreadPool(int)(固定大小线程池)
- Executors.newSingleThreadExecutor()(单个后台线程)
它们均为大多数使用场景预定义了设置。
/** * 线程池:提供了一个线程队列,队列中保存着所有等待状态的线程.避免了创建与销毁额外开销,提高响应的速度 * 线程池体系结构: * java.util.concurrent.Executor:负责线程的使用与调度的根接口 * |--ExcutorExecutor 子接口:线程池的主要接口 * |--ThreadPoolExecutor:实现类 * |--ScheduledExecutorService 子接口:负责线程的调度 * |--ScheduledThreadPoolExecutor:继承ThreadPoolExecutor,实现ScheduleExecutorService * * 工具类:Executors * ExecutorService newFixedThreadPool():创建固定大小的连接池 * ExecutorService newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量 * ExecutorService newSingleThreadPoolI):创建单个线程池,线程池中只有一个线程 * * ScheduledThreadPoolExecutor newScheduledThreadPool():创建固定大小的线程池,可以延迟或者定时完成任务 */ public class TestThreadPool { public static void main(String[] args) throws Exception { //1.创建线程池 ExecutorService pool = Executors.newFixedThreadPool(6); ThreadPoolDemo threadPoolDemo = new ThreadPoolDemo(); for (int i = 0; i < 5; i++) { //2.为线程池中线程分配任务 pool.submit(threadPoolDemo); } //创建list接收Future List<Future<Integer>> list = new ArrayList<>(); for (int i = 0; i < 5; i++) { //为线程池中线程分配任务 Future<Integer> future = pool.submit(new Callable<Integer>() { @Override public Integer call() throws Exception { int sum = 0; for (int j = 0; j <= 100; j++) { sum += j; } return sum; } }); list.add(future); } //3.关闭线程池 pool.shutdown(); for (Future<Integer> future : list) { System.out.println(future.get()); } } } class ThreadPoolDemo implements Runnable{ private int i = 0; @Override public void run() { while (i < 100) { System.out.println(Thread.currentThread().getName() + ":" + i++); } } }
线程调度 ScheduledExecutorService
一个 ExecutorService,可安排在给定的延迟后运行或定期执行的命令。
/** * 调度线程池 */ public class TestScheduledThreadPoolExecutor { public static void main(String[] args) throws Exception { //创建调度线程池 ScheduledExecutorService pool = Executors.newScheduledThreadPool(5); for (int i = 0; i < 10; i++) { //线程调度 ScheduledFuture<Integer> future = pool.schedule(new Callable<Integer>() { @Override public Integer call() throws Exception { int num = new Random().nextInt(100); System.out.println(Thread.currentThread().getName() + ":" + num); return num; } }, 1, TimeUnit.SECONDS); System.out.println(future.get()); } //关闭线程池 pool.shutdown(); } }
ForkJoinPool 分支/合并框架 工作窃取
Fork/Join 框架:就是在必要的情况下,将一个大任务,进行拆分(fork)成若干个小任务(拆到不可再拆时),再将一个个的小任务运算的结果进行 join 汇总。
Fork/Join 框架与线程池的区别:
- 采用 “工作窃取”模式(work-stealing):
当执行新的任务时它可以将其拆分分成更小的任务执行,并将小任务加到线程队列中,然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。
- 相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态。而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能。
/** * ForkJoinPool分支/合并框架 */ public class TestForkJoinPool { public static void main(String[] args) { //jdk1.8中的Instant Instant start = Instant.now(); ForkJoinPool pool = new ForkJoinPool(); ForkJoinTask<Long> task = new ForkJoinSumCalculate(0L, 100000000L); Long sum = pool.invoke(task); System.out.println("结果: "+sum); Instant end = Instant.now(); System.out.println("耗时: " + Duration.between(start, end).toMillis() + "秒"); } /** * java8 新特性 */ @Test public void test(){ Instant start = Instant.now(); Long sum = LongStream.rangeClosed(0L, 100000000L) .parallel() .reduce(0L, Long::sum); System.out.println("结果: "+sum); Instant end = Instant.now(); System.out.println("耗时: " + Duration.between(start, end).toMillis() + "秒"); } } class ForkJoinSumCalculate extends RecursiveTask<Long>{ private static final long serialVersionUID = -2413341168893070665L; private long start; private long end; //设置临界值 private static final long THURSHOLD = 10000L; public ForkJoinSumCalculate(long start, long end) { this.start = start; this.end = end; } @Override protected Long compute() { long length = end -start; if (length <= THURSHOLD ) { long sum = 0L; for (long i = start; i <= end; i++) { sum += i; } return sum; } else { long middle = (start + end)/2; ForkJoinSumCalculate left = new ForkJoinSumCalculate(start,middle); //进行拆分,同时压入线程队列 left.fork(); ForkJoinSumCalculate right = new ForkJoinSumCalculate(middle+1, end); //进行拆分,同时压入线程队列 right.fork(); return left.join() + right.join(); } } }
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- JAVA多线程编程总结
- Java多线程编程总结
- Java 多线程编程总结
- Java多线程编程总结
- Java多线程编程总结
- A003-算法-滑动窗口队列(未测试)
- windows tcp buffer size 调研
- 3、类和接口
- BZOJ3211 花神游历各国 线段树+并查集
- <模型汇总-5>开山鼻祖-深度信念网络DBN
- Java多线程编程总结
- <转载>名言
- 检验输入的mac是否是符合mac形式
- 将数据封装为Json数据格式
- 5、方法
- Gym
- DELL服务器r231011安装操作系统
- bzoj1107[POI2007]驾驶考试egz LIS
- poj3977(折半搜索)