多线程编程

一、创建线程

1.继承 Thread 类，重写 run() 方法

栗子：
```
public class TestThread extends Thread {

  @Override
  public void run() {
      System.out.println("Hello World");
  }

  
  public static void main(String[] args) {
      TestThread t = new TestThread();
      t.start();
  }
 }
```
注意啦！！！注意啦！！！注意啦！！！

调用 start() 方法并不会立即执行多线程的代码，而是将该线程变为可运行状态，什么时候运行多线程代码又操作系统决定。

2.实现 Runnable 接口，实现该接口的 run() 方法

栗子：

public class MyRunnable implements Runnable{

  @Override
  public void run() {
      System.out.println("Hello World");
  }

  public static void main(String[] args) {
      Thread t = new Thread(new MyRunnable());
      t.start();
  }
}

3.实现 Callable 接口，实现该接口的 call() 方法

Callable 接口和 Runnable 接口功能类似，它是 Executor 框架的功能类，它比 Runnable 更强大的地方在于：
- Callable 可以在任务接受后提供一个返回值，Runnable 无法提供这个功能
- Callable 中的 call() 可以抛出异常，Runnable 的 run() 遇到异常线程就停止了，不能抛出
- 运行 Callable 能拿到一个 Future 对象，这个对象表示异步计算的结果。通过调用 Future 对象的 get() 方法，就能获取线程的计算结果。
  栗子：
```
public class MyCallable implements Callable<Integer>{

  @Override
  public Integer call() throws Exception {
      return 10*1093;
  }

  public static void main(String[] args) {
      MyCallable c = new MyCallable();
      ExecutorService executorService = Executors.newSingleThreadExecutor();
      Future<Integer> future = executorService.submit(c);
      
      try {
          System.out.println(future.get());
      }catch (Exception e) {
          e.printStackTrace();
      }
  }
}
```

推荐使用第二种方法，直接实现 Runnable 接口。

二、volatile

vloatile 无法保证变量的原子性
可见性
有序性

可用于双重检查的单例模式

public class Singleton {

    private volatile static Singleton instance = null;
    
    public  static Singleton getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        
        return instance;
    }
}

三、java 中的阻塞队列

1.ArrayBlockingQueue： 由数组结构组成的有界阻塞队列
2.LinkedBlockingQueue： 基于链表的有界阻塞队列
3.PriorityBlockingQueue： 支持优先级排序的无界阻塞队列
4.DelayQueue： 使用优先级队列实现的无界阻塞队列，支持延时获取元素
**5.SynchronousQueue: ** 不存储元素的阻塞队列
**6.LinkedTransferQueue: ** 由链表组成无界阻塞队列
**7.LinkedBlockingDqueue: ** 由链表组成的双向阻塞队列

四、线程池

1.FixedThreadPool： 可重用固定线程数的线程池。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
 }

这种线程池只有核心线程，并且数量是固定的，没有非核心线程。

工作流程：当执行 execute() 时，如果线程池的核心线程数还没达到 corePoolSize ，就创建核心线程执行任务，否则就将任务丢进无界的阻塞队列中，当有核心线程空闲时再去执行任务。

2.CachedThreadPool： 根据需要创建线程的线程池

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

这种线程池没有核心线程，非核心线程是无界的。空闲线程等待新任务的最长时间是 60s。在这里用了 SynchronousQueue 不存储元素的阻塞队列，每个插入操作必须等待另一个线程的移除操作，同样任何一个移除操作都必须等待另一个线程的插入操作。

3. SingleThreadExecutor：使用单个工作线程的线程池

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}

这种线程池能按照顺序逐一执行任务。

4. ScheduleThreadPool： 实现定时和周期性任务的线程池

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
}

这里使用的是优先级队列实现的无界阻塞队列，线程启动时需要延时获取任务，所以能实现延时或者周期执行。

多线程编程

一、创建线程

二、volatile

三、java 中的阻塞队列

四、线程池

推荐阅读更多精彩内容