java并发编程

上一篇	下一篇
常用的设计模式	暂无

1、继承 Thread 类

java已经为多线程提供了内置的支持，java的 Thread 类已经将线程封装好，只需要继承 Thread 类，然后重写run()方法即可。

例：张三和李四去银行取钱

线程类：

public class Person extends Thread {
    @Override
    public void run() {
        try {
            System.out.println(getName() + " 开始取钱");
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName() + " 取钱完毕");
    }
}

运行线程只需要调用start()方法启动即可，run()方法是调用start()方法后执行的。
运行线程：

public class Bank {
    public static void main(String[] args) {
        Person thread1 = new Person();
        thread1.setName("张三");

        Person thread2 = new Person();
        thread2.setName("李四");

        thread1.start();
        thread2.start();
    }
}

类图：

Thread 类里就已经有了name属性，所以可以调用setName()设置属性。

2、实现 Runnerable 接口

因为java是单继承，继承 Thread 线程后，无法再继承其他类。导致程序的可扩展性降低。
多以定义多线程程序，优先采用第二种方式：实现java.lang.Runnerable接口
Runnerable接口里只有一个待实现方法run()，属性得自己补充

public class Person implements Runnable {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        try {
            System.out.println(name + " 开始取钱");
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + " 取钱完毕");
    }
}

Runnerable接口的线程类，还需要包装在 Thread 类的实例中运行：

public class Bank {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.setName("张三");
        Thread thread1 = new Thread(person1);

        Person person2 = new Person();
        person2.setName("李四");
        Thread thread2 = new Thread(person2);

        thread1.start();
        thread2.start();
    }
}

类图：

3、线程安全与synchronized

synchronized用来给资源上锁，使用了synchronized的方法满足了两个线程安全的特性：

1. 原子性：方法全部执行并且执行的过程不会被任何因素打断。
2. 可见性：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

它让方法变成了临界资源，通俗来讲，就是一次只有一个线程能够运行这个方法。

4、悲观锁和乐观锁

乐观锁其实没有上锁，但却能保证数据操作的原子性。由于没有上锁，提高了性能，不上锁的思想是乐观的，所以称为乐观锁。java.util.concurrent是java系统提供的一个并发编程包，java.util.concurrent.atomic提供了不使用synchronized就能保证数据操作原子性的方法。

相对来说，synchronized关键字是给整个方法上锁，这种思想是悲观的，它假设其他线程一定会修改数据，所以提前防范，所以称之为悲观锁。

总结下二者的区别：
乐观锁
不适用于多条数据需要修改、以及多个操作的整体顺序要求很严格的场景，乐观锁适用于读数据比重更大的应用场景。
悲观锁
适合写数据比重更大的应用场景。一般来说写数据的整体消耗时间更长些，是可以接受的。

5、并发容器

基本的多线程编程不利于任务的管理，在 java8 时代，使用新的completableFuture技术可以让多线程并发编程更加优雅。

直接来个用法核心代码：

Register reg = new Register();

CompletableFuture.supplyAsync(() -> reg.regId(s))
  .thenApply(student -> {
    return dis.assignClasses(student);
  })
  .thenAccept(student -> {
     System.out.println("姓名：" + student.getName() + "，学号：" + student.getId() + "，班级号：" + student.getClassId());
  });

这里的Register类就不需要实现Runnerable接口，就只是一个普通的类。
系统会自动优化，把作为CompletableFuture.supplyAsync()方法参数的() -> reg.regId(s)表达式语句封装到另一个对象中，这个对象是JDK内置的，它实现了Runnerable接口，在这个对象中执行表达式语句。
所以实际上，CompletableFuture.supplyAsync()的作用是开启一个单线程运行() -> reg.regId(s)，本质上就是多线程编程。
并且在() -> reg.regId(s)执行完后，会继续执行后面的.thenApply()和.thenAccept()里的语句，.thenAccept()是任务链的尾端。

其中，除了thenAccept()不一定，其余的都一定要返回值，一条任务链中，后继任务需要前趋任务的返回值才能开始执行。（如果不需要前趋任务的返回值的话，也就没有必要安排在同一个任务链中了）
并且，它们的返回值都是CompletableFuture实例对象，这就能将上面这一点串起来的，任务链的每个任务结束返回一个CompletableFuture实例对象，然后继续用这个对象执行接下来的任务。

main() 方法提前结束问题

当线程比较多，执行时间比较长时，可能线程任务还没执行完毕，main()方法就执行完毕了，导致程序运行退出。
要解决这个问题，可以利用返回值。我们先把每个学生的入学任务实例对象CompletableFuture<Void>收集起来(装入集合)。然后等待所有的线程执行完毕。

List<CompletableFuture> cfs = new ArrayList<>();
studentList.forEach(s -> {
  CompletableFuture<Void> cf = CompletableFuture.supplyAsync(() -> reg.regId(s))
    .thenApply(student -> {
        return dis.assignClasses(student);
    }).thenAccept(student -> {
        System.out.println("姓名：" + student.getName() + "，学号：" + student.getId() + "，班级号：" + student.getClassId());
    });

  cfs.add(cf);
});

try {
  // 等待所有的线程执行完毕
  CompletableFuture.allOf(cfs.toArray(new CompletableFuture[] {})).get();
} catch (Exception e) {
  e.printStackTrace();
}

CompletableFuture.al10f()是静态方法，作用就是收集所有的任务实例对象因为allOf()方法只支持数组不支持集合，所以需要把集合转换成数组cfs.toArray(new CompletableFuture[] {})。allOf()方法的返回值也是CompletableFuture实例对象。
再调用类方法get(),其作用就是等待所有的任务线程(allOf()收集的)都执行完毕，再继续执行。

CompletableFuture有点像Stream API里的ParallelStream，其实它们都是并发容器，但是ParallelStream侧重流元素的计算操作，而CompletableFuture的任务就比较广泛。

6、线程池

使用Runnerable接口开发多线程程序时，每个对象的创建、销毁，会消耗计算机的CPU、内存等资源，当线程多起来后，这些操作所浪费的资源十分“可观”。
而线程池，就能做到优化，复用Thread对象。

所谓线程池，就像是一个池子，里面装了很多线程，这些线程可以被复用，执行完任务A的线程可以回收用于任务B的执行，不用苦于创建于销毁。

创建线程池的核心代码：

根据《阿里巴巴Java开发手册》(业界著名的开发规约)，创建线程池的核心代码是:

import org.apache.commons.lang3.concurrent.BasicThreadFactory;

import java.util.concurrent.*;

public class StudentIDTest {

  // 线程工厂
  private static final ThreadFactory namedThreadFactory = new BasicThreadFactory.Builder()
    .namingPattern("studentReg-pool-%d")
    .daemon(true)
    .build();

  // 等待队列
  private static final BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>(1024);

  // 线程池服务
  private static final ThreadPoolExecutor EXECUTOR_SERVICE = new ThreadPoolExecutor(
        20,
        200,
        30,
        TimeUnit.SECONDS,
        workQueue,
        namedThreadFactory,
        new ThreadPoolExecutor.AbortPolicy()
      );

  public static void main(String[] args) {

  }
}

先来看用法：

import org.apache.commons.lang3.concurrent.BasicThreadFactory;

import java.util.concurrent.*;

public class StudentIDTest {
    // 线程工厂
    private static final ThreadFactory namedThreadFactory = new BasicThreadFactory.Builder().namingPattern(
        "studentReg-pool-%d").daemon(true).build();

    // 等待队列
    private static final BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>(1024);
    // 线程池服务
    private static final ThreadPoolExecutor EXECUTOR_SERVICE = new ThreadPoolExecutor(20, 100, 60, TimeUnit.SECONDS,
                                                                                      workQueue, namedThreadFactory,
                                                                                      new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        // 构建学生集合
        for (int i = 1; i <= 2000; i++) {
            Student s = new Student();
            s.setName("学生" + i);
            Register register = new Register(s);
            // 传入 Runnable 对象，运行任务
            EXECUTOR_SERVICE.execute(register);
        }
    }
}

代码中的Student类是已经写好的学生类，Register也是，并且Register是Runnerable接口的实现类。
从代码中可以看到，线程池创建好后，就只需要执行EXECUTOR_SERVICE.execute(“要执行的任务类”);，即可将写好的任务类抛给线程池，线程池会适时为它开辟线程执行。

核心代码分析

创建线程池的代码，基本上属于固定写法，大概记住就好。

一、创建线程工厂实例

// 线程工厂
  private static final ThreadFactory namedThreadFactory = new BasicThreadFactory.Builder()
    .namingPattern("studentReg-pool-%d")
    .daemon(true)
    .build();

就是用来生产线程池中的线程，namingPattern()方法是定义线程池中线程名字的格式，线程名称模板。

二、创建线程等待队列实例

// 等待队列
  private static final BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>(1024);

当线程池没有空闲的线程时，多余的任务就挂在等待队列上等待分配线程。

如果机器性能好，CPU 核数多(6、 8核)、内存大，队列可以大一些:new LinkedBlockingQueue<Runnable>(2048)。构造函数的参数表示能排队任务个数。

如果机器性能好，CPU核数少(1、 2核)、内存大，队列就小一些:new LinkedBlockingQueue<Runnable>(512)

一般来说，new LinkedBlockingQueue<Runnable>(1024)也还可以。

三、创建线程池实例

   // 线程池服务
  private static final ThreadPoolExecutor EXECUTOR_SERVICE = new ThreadPoolExecutor(
        20,
        200,
        30,
        TimeUnit.SECONDS,
        workQueue,
        namedThreadFactory,
        new ThreadPoolExecutor.AbortPolicy()
      );

ThreadPoolExecutor构造函数的参数比较多：

参数序号	解释
1	线程池初始化核心线程数量，一般是两位数，通常不大
2	线程池最大线程数，计算机性能强就大一些，否则小些，通常不超过200
3	线程池中的线程数超过核心线程数时，如果一段时间后还没有任务指派，就回收了。立即回收就填0，一般填30
4	第三个参数的时间单位。30 + TimeUnit.SECONDS表示30秒
5	等待队列实例（已经创建过了）
6	线程工厂实例（已经创建过了）
7	任务太多，超过队列的容量时，用什么样的策略处理。一般用AbortPolicy表示拒绝，主程序自己处理

即便是相比于多线程编程，线程池能方便管理更多的线程。实际编程工作中，仍要想办法保证不要创建太多的任务，要有所控制，而不是只管创建任务扔进线程池。比如可以采用分页的思想，分批处理。一批只处理几十个、一二百个任务。还要考虑任务执行时间，能不能快速结束。不要让一台计算机堆积太多任务,保证线程等待队列能容纳。（就是想操作系统管理分配内存那样，管理线程池里的线程资源）

7、线程池与并发容器

实际上，CompletableFuture内部也用到了线程池：

CompletableFuture.supplyAsync(
    () -> reg.regId(s)
  )

实际上是把任务放进默认的线程池里执行。

CompletableFuture也可以指定线程池来运行任务（supplyAsync()方法可以有第二个参数，传入构建好的线程池，那么任务就是用指定的线程池而不是默认线程池）：

CompletableFuture.supplyAsync(
    () -> reg.regId(s),
    EXECUTOR_SERVICE
  )

来看看java系统升级迭代进程

基础多线程编程
      ↓
    线程池
      ↓
   并发容器         

一般来说，小场面就用supplyAsync(() -> {})就够了，当遇到任务并发度高、任务量大、任务执行慢的情况下，就要考虑指定线程池，调整线程池参数。

上一篇	下一篇
常用的设计模式	暂无