手册   游戏   WEB   字典   单词   在线工具  

java - 并发编程

1, 并发编程

并发通常能提高单处理器的程序性能. 可是, 看到这句话有些违背直觉. 多线程的运行增加了线程间切换的开销, 仅仅从这个角度看, 单线程运行总比多线程的性能好. 但是, 程序的阻塞会使得结果不一样, 当某个线程阻塞时候, 其它线程仍然可以执行, 因此程序仍保持运行. 充分利用 cpu 的时间提高的性能远大于线程间的切换带来的性能下降.

何为阻塞: 程序中某个线程由于在不满足某些条件的情况下而导致不能够继续执行的现象

2, 基本线程机制:

一个程序可以分为多个独立运行任务, 每个独立任务由线程驱动执行. 线程并发执行, 表面看起来是同时执行, 好像各自都有一个自己的 CPU 一样. 实际上, 底层机制是 CPU 将时间片分给各个线程, 一个时间只能有一个线程获得 CPU 的时间片, 也就是线程独占 CPU 资源.

3, 定义任务类, 定义线程类

定义任务

  1. package com.duoxiancheng;
  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  4. public class Main {    public static void main(String[] args) {
  5.         for (int i=0; i<2; i++) {
  6.           new Thread(new LiftOff()).start();
  7.         }
  8.     }
  9. }
  10. class LiftOff implements Runnable{
  11.     private int countDown=3;
  12.     private static int taskCount=0;
  13.     private final int id=taskCount++;
  14.     @Override
  15.     public void run() {
  16.         while (countDown-->0) {
  17.             System.out.println("#id=" + id + "countDown="+(countDown> 0 ? countDown : "LiftOff!"));
  18.             Thread.yield();
  19.         }
  20.     }
  21. }

输出结果

  1. #id=0 countDown=2
  2. #id=1 countDown=2
  3. #id=0 countDown=1
  4. #id=1 countDown=1
  5. #id=0 countDown=LiftOff!
  6. #id=1 countDown=LiftOff!

定义线程类

  1. package com.duoxiancheng;
  2. public class Main {
  3.     public static void main(String[] args) {
  4.         for (int i=0; i<2; i++) {
  5.           new LiftOff().start();
  6.         }
  7.     }
  8. }
  9. class LiftOff extends Thread{
  10.     private int countDown=3;
  11.     private static int taskCount=0;
  12.     private final int id=taskCount++;
  13.     @Override
  14.     public void run() {
  15.         while (countDown-->0) {
  16.             System.out.println("#id=" + id + "countDown="+(countDown> 0 ? countDown : "LiftOff!"));
  17.             Thread.yield();
  18.         }
  19.     }
  20. }

4, 线程池

待续...

5, 从任务中产生返回值 ---Callable<T > 接口

  1. package com.duoxiancheng;
  2. import java.util.concurrent.*;
  3. public class Main1 {
  4.     public static void main(String[] args) throws Exception{
  5.         ExecutorService executorService= Executors.newCachedThreadPool();
  6.         for (int i=0;i<50;i++){
  7.             Future future = executorService.submit(new TaskWithResult(i));
  8.             Object result = future.get();
  9.             System.out.println(result);
  10.         }
  11.     }
  12. }
  13. class TaskWithResult implements Callable{
  14.     private int id=0;
  15.     public TaskWithResult(int id){
  16.         this.id=id;
  17.     }
  18.     @Override
  19.     public Object call() throws Exception {
  20.         return id;
  21.     }
  22. }

其中 future.get()是阻塞的方法; 如果想想立即阻塞任务的等待, 则可以使用 result = exec.submit(aCallable).get(); 形式

6, 常用方法

休眠 ---sleep()

让步 ---yield()

加入一个线程 ---join()

优先级 --setPriority()/getPriority()

后台线程 --setDaemon()/isDaemon()

...

7, 捕获线程中的异常

线程中抛出异常, 会传播到控制台, 除非采用特殊手段.

  1. public interface Runnable {
  2.     public abstract void run();
  3. }

在 run()方法内部 try-catch-finally 捕获异常

使用异常处理器捕获异常 -- 异常处理器实现 Thread.UncaughtExceptionHandler 接口

以下分析自定义异常处理器:

为线程设置异常处理器. 具体做法可以是以下几种:

(1)Thread.setUncaughtExceptionHandler 设置当前线程的异常处理器;

(2)Thread.setDefaultUncaughtExceptionHandler 为整个程序设置默认的异常处理器;

如果当前线程有异常处理器(默认没有), 则优先使用该 UncaughtExceptionHandler 类; 否则, 如果当前线程所属的线程组有异常处理器, 则使用线程组的

UncaughtExceptionHandler; 否则, 使用全局默认的 DefaultUncaughtExceptionHandler; 如果都没有的话, 子线程就会退出

  1. package com.duoxiancheng;
  2. import java.util.concurrent.ThreadFactory;
  3. public class Main2 {
  4.     public static void main(String[] args) {
  5.         Thread thread=new Thread(new ExceptionThread());
  6.         thread.setUncaughtExceptionHandler(new MyExceptionHandler());
  7.         thread.start();
  8.     }
  9. }
  10. /**
  11.  * 任务类
  12.  */
  13. class ExceptionThread implements Runnable{
  14.     @Override
  15.     public void run() {
  16.         Thread t = Thread.currentThread();
  17.         System.out.println("ExceptionThread 当前线程信息:"+t.toString());
  18.         System.out.println("当前线程 ExceptionThread 的异常处理器"
  19.                 +t.getUncaughtExceptionHandler());
  20.         throw new RuntimeException();
  21.     }
  22. }
  23. /**
  24.  * 线程异常处理器
  25.  */
  26. class MyExceptionHandler implements Thread.UncaughtExceptionHandler {
  27.     @Override
  28.     public void uncaughtException(Thread t, Throwable e) {
  29.         System.out.println("抛出的异常是:"+e);
  30.     }
  31. }

8, 共享资源

共享资源竞争:

导致线程安全问题

解决思想:

多人 (线程) 都希望单独使用浴室(共享资源). 为了使用浴室, 一个人先敲门, 看能不能使用. 如果没人回话, 他就进入浴室并锁上门(获得锁). 这时候, 其它人想使用浴室的话, 就会被阻挡在外面(不能获取锁), 直到浴室可以使用. 浴室外面的人没有排队, 浴室门打开(前一个人释放锁), 离门最近的人优先进入使用(获得锁, 设置优先级和 yield 方法可以建议某个优先使用).

解决方式:

Synchronized ,Lock 锁同步以及 Voliate 修饰符和原子类

线程本地存储 ---ThreadLocal

9, 线程之间协作

生产者与消费者

  1. package com.duoxiancheng;
  2. import java.util.concurrent.locks.Condition;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5. /**
  6.  *  生产者 - 消费者
  7.  */
  8. public class Main3 {
  9.     public static void main(String[ ] args) throws InterruptedException {
  10.         Restaurant restaurant=new Restaurant();
  11.         new Thread(new ProductorThread(restaurant)).start();
  12.         Thread.sleep(20);
  13.         new Thread(new ConsumerThread(restaurant)).start();
  14.     }
  15. }
  16. class Restaurant {
  17.     Lock lock=new ReentrantLock();// 锁
  18.     Condition condition1=lock.newCondition();// 条件 1
  19.     Condition condition2=lock.newCondition();// 条件 2
  20.     private int count;// 已做好的餐
  21.     private int count2;
  22.     /**
  23.      * 消费者方法
  24.      */
  25.     public void comsumer(){
  26.         lock.lock();
  27.         try {
  28.             if (count==0) {
  29.                 System.out.println(Thread.currentThread().getId()+"客户 想要一份快餐!");
  30.                 condition2.signalAll();
  31.                 System.out.println(Thread.currentThread().getId()+"客户 等待一份快餐!");
  32.                 condition1.await();
  33.             }
  34.             count--;
  35.             System.out.println(Thread.currentThread().getId()+ "客户 消费了一份快餐!");
  36.         } catch (InterruptedException e) {
  37.             e.printStackTrace();
  38.         }finally {
  39.             lock.unlock();
  40.         }
  41.     }
  42.     /**
  43.      * 生产者方法
  44.      */
  45.     public void productor(){
  46.         lock.lock();
  47.         try {
  48.             condition2.await();
  49.             count++;// 生产一份快餐
  50.             System.out.println(Thread.currentThread().getId()+ "厨师 制作了一份快餐!");
  51.             condition1.signalAll();
  52.             System.out.println(Thread.currentThread().getId()+"厨师 通知客户使用");
  53.         }catch (InterruptedException e){
  54.             e.printStackTrace();
  55.         }finally {
  56.             lock.unlock();
  57.         }
  58.     }
  59. }
  60. /**
  61.  * 消费者
  62.  */
  63. class ConsumerThread implements Runnable{
  64.     private Restaurant restaurant;
  65.     public ConsumerThread(Restaurant restaurant){
  66.         this.restaurant=restaurant;
  67.     }
  68.     @Override
  69.     public void run() {
  70.         restaurant.comsumer();
  71.     }
  72. }
  73. /**
  74.  * 生产者
  75.  */
  76. class ProductorThread implements Runnable{
  77.     private Restaurant restaurant;
  78.     public ProductorThread(Restaurant restaurant){
  79.         this.restaurant=restaurant;
  80.     }
  81.     @Override
  82.     public void run() {
  83.         restaurant.productor();
  84.     }
  85. }

输出结果:

11 客户 想要一份快餐!

11 客户 等待一份快餐!

10 厨师 制作了一份快餐!

10 厨师 通知客户使用

11 客户 消费了一份快餐!

生产者与消费者 和 队列

使用 wait(),notifyAll() 是一种解决任务互操作问题非常低级的方式. 使用同步队列来解决任务协作问题, 同步队列在任何时刻只允许一个任务插入或移除.

java.util.concurrent.BlockingQueue 接口提供了这个同步队列, 其有大量的实现. 通常可以使用 LinkedBlockingDeque(无界队列) 和 ArrayBlockingDeque(固定尺寸队列).

消费者任务试图从队列中获取对象, 而该队列此时为空, 那这些队列还可以挂起消费者任务(阻塞); 当有更多元素可用时恢复消费者任务. 阻塞队列可以解决非常大量的问题.

  1. package com.duoxiancheng;
  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  4. import java.util.concurrent.LinkedBlockingDeque;
  5. /**
  6.  * 生产者 - 消费者与队列
  7.  */
  8. public class Main4 {
  9.     public static void main(String[] args) {
  10.         ExecutorService executorService= Executors.newCachedThreadPool();
  11.         LinkedBlockingDeque<Toast> toastQueue=new LinkedBlockingDeque<>();
  12.         LinkedBlockingDeque<Toast> butteredQueue=new LinkedBlockingDeque<>();
  13.         LinkedBlockingDeque<Toast> jammedQueue=new LinkedBlockingDeque<>();
  14.         executorService.execute(new Toaster(toastQueue));
  15.         executorService.execute(new Butterer(toastQueue, butteredQueue));
  16.         executorService.execute(new Jammed(butteredQueue, jammedQueue));
  17.         executorService.execute(new Eater(jammedQueue));
  18.     }
  19. }
  20. class Toast{
  21.     private Status status=Status.DRY;
  22.     private final int id;
  23.     public Toast(int id) {
  24.         this.id = id;
  25.     }
  26.     public int getId() {
  27.         return id;
  28.     }
  29.     public Status getStatus() {
  30.         return status;
  31.     }
  32.     public void addButtered(){
  33.         status=Status.BUTTERED;
  34.     }
  35.     public void addJammed(){
  36.         status=Status.JAMMED;
  37.     }
  38.     @Override
  39.     public String toString() {
  40.         return "Toast"+id+":"+status;
  41.     }
  42.     /**
  43.      * 枚举类型
  44.      */
  45.     public enum Status{
  46.         DRY,BUTTERED,JAMMED
  47.     }
  48. }
  49. /**
  50.  * 制作吐司
  51.  */
  52. class Toaster implements Runnable{
  53.     private LinkedBlockingDeque<Toast> toastQueue;
  54.     private int count;
  55.     public Toaster(LinkedBlockingDeque toastQueue){
  56.         this.toastQueue=toastQueue;
  57.     }
  58.     @Override
  59.     public void run() {
  60.         try {
  61.             for (int i = 0; i <5; i++) {
  62.                 Toast toast = new Toast(count++);
  63.                 System.out.println(toast);
  64.                 toastQueue.put(toast);
  65.                 Thread.sleep(100);
  66.             }
  67.         } catch (InterruptedException e) {
  68.             e.printStackTrace();
  69.         }
  70.     }
  71. }
  72. /**
  73.  * 添加黄油
  74.  */
  75. class Butterer implements Runnable{
  76.     private LinkedBlockingDeque<Toast> toastQueue;
  77.     private LinkedBlockingDeque<Toast> butteredQueue;
  78.     public Butterer(LinkedBlockingDeque toastQueue,LinkedBlockingDeque butteredQueue){
  79.         this.toastQueue=toastQueue;
  80.         this.butteredQueue=butteredQueue;
  81.     }
  82.     @Override
  83.     public void run() {
  84.         try {
  85.             for (int i = 0; i <5; i++) {
  86.                 Toast toast = toastQueue.take();
  87.                 toast.addButtered();
  88.                 System.out.println("添加黄油," + toast);
  89.                 butteredQueue.put(toast);
  90.             }
  91.         }catch (InterruptedException e){
  92.             e.printStackTrace();
  93.         }
  94.     }
  95. }
  96. /**
  97.  * 添加果酱
  98.  */
  99. class Jammed implements Runnable{
  100.     private LinkedBlockingDeque<Toast> butteredQueue;
  101.     private LinkedBlockingDeque<Toast> jammedQueue;
  102.     public Jammed(LinkedBlockingDeque butteredQueue, LinkedBlockingDeque jammedQueue){
  103.         this.butteredQueue=butteredQueue;
  104.         this.jammedQueue=jammedQueue;
  105.     }
  106.     @Override
  107.     public void run() {
  108.         try {
  109.             for (int i = 0; i <5; i++) {
  110.                 Toast toast = butteredQueue.take();
  111.                 toast.addJammed();
  112.                 System.out.println("添加果酱," + toast);
  113.                 jammedQueue.put(toast);
  114.             }
  115.         }catch (InterruptedException e){
  116.             e.printStackTrace();
  117.         }
  118.     }
  119. }
  120. /**
  121.  * 消费吐司
  122.  */
  123. class Eater implements Runnable{
  124.     private LinkedBlockingDeque<Toast> jammedQueue;
  125.     public Eater(LinkedBlockingDeque jammedQueue){
  126.         this.jammedQueue=jammedQueue;
  127.     }
  128.     private int counter;
  129.     @Override
  130.     public void run() {
  131.         try {
  132.             for (int i = 0; i < 5; i++) {
  133.                 Toast toast = jammedQueue.take();
  134.                 if (toast.getStatus() != Toast.Status.JAMMED) {
  135.                     System.out.println("=====ERROR=====");
  136.                 } else {
  137.                     System.out.println("消费了一个吐司");
  138.                 }
  139.             }
  140.         } catch (InterruptedException e) {
  141.             e.printStackTrace();
  142.         }
  143.     }
  144. }

10, 死锁

某个线程在等待另一个线程释放锁, 而后者又在等别的线程的所, 这样一直下去, 直到整个链条上的线程又在等第一个线程释放锁. 这样线程之间的相互等待的连续循环, 导致没有哪个线程能继续执行的现象.

死锁四大条件:

请求与保持

不可剥夺

互斥条件

循环等待

防止死锁:

发生死锁必须全部满足四大条件, 要避免死锁, 只需破坏其中一个即可.

来源: https://www.cnblogs.com/shixiemayi/p/9460141.html


与本文相关文章

  1. Java-- 并发编程
  2. [并发编程] Java 中的原子操作
  3. Java 并发编程之 Lock
  4. Java 并发编程基础 -- 同步
  5. 一文看尽 Java - 并发编程知识点
  6. 并发编程之 Java 三把锁
  7. java 并发编程 (一)
  8. Java 并发编程 - 重入锁
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1