java并发基础及原理

java并发基础知识导图

一 java线程用法

1.1 线程使用方式

1.1.1 继承Thread类

继承Thread类的方式,无返回值,且由于java不支持多继承,继承Thread类后,无法再继承其他类。

 /**

  * 继承Thread类的方式创建线程

  */

 public class ThreadExtendTest extends Thread{

     @Override

     public void run() {

         System.out.println("create thread by thread extend");

     }

     public static void main(String[] args) {

         new ThreadExtendTest().start();

     }

 }

1.1.2 实现Runnable接口

无返回值,但由于实现的是接口,可以继承其他类。

 /**

  * 实现Runnable接口的方式创建线程，无返回值

  */

 public class ThreadRunnableTest implements Runnable{

     @Override

     public void run() {

         System.out.println("create thread by runnable implements");

     }

     public static void main(String[] args) {

         new Thread(new ThreadRunnableTest()).start();

     }

 }

1.1.3 实现Callable接口

有返回值,且可以继承其他类。

 /**

  * 实现Callable接口,和FutureTask结合,创建线程，有返回值

  */

 public class ThreadCallableTest implements Callable<String> {

     @Override

     public String call() throws Exception {

         return "create thread by implements Callable";

     }

     public static void main(String[] args) throws ExecutionException, InterruptedException{

         FutureTask<String> future1 = new FutureTask<String>(new ThreadCallableTest());

         Thread thread1 = new Thread(future1);

         thread1.start();

         System.out.println(future1.get());

     }

 }

1.1.4 Runnable或Callable和Future结合的线程池方式

 /**

  * 线程池的方式使用线程

  */

 public class ThreadPoolTest implements Callable<String> {

     @Override

     public String call() throws Exception {

         return "create thread by thread pool";

     }

     public static void main(String[] args) throws ExecutionException, InterruptedException{

         ExecutorService executorService = Executors.newFixedThreadPool(1);

         Future<String> future1 = executorService.submit(new ThreadPoolTest());

         System.out.println(future1.get());

         executorService.shutdown();

     }

 }

java线程的四种用法,本质其实分为两类,一个是继承方式,一个是实现接口方式,由于java只支持单继承,继承Thread类后,不能再继承其他类,而使用实现接口的方式,还可以再继承其它有用的类。Runnable方式无返回值,Callable用于需要返回值的场景。利用线程池创建线程，实际上依然是借助Runnable或者Callable。

1.2 线程状态

java线程状态分为NEW、RUNNABLE、BLOCKED、TIME_WAITING、WAITING、TERMINATED六种状态,线程状态间可以转换,状态转换图如下:

图1.1 java线程状态转换图

当进程出现问题时，可查看进程各线程的运行状况。

ps -aux | grep java查看进程pid,如图1.2。
top -Hp pid,查看进程各线程cpu、内存等占用情况，如图1.3。
jstack pid,查看进程各线程的堆栈信息,包括运行状态等,如图1.4。

图1.2 查找进程pid

图1.3 查看进程各线程资源占用

图1.4 查看线程状态

1.3 安全终止线程

1.3.1 volatile变量+轮询

 /**

  * volatile变量+轮询安全终止线程

  */

 class VolatileThread implements Runnable{

     private volatile boolean cancelled;

     @Override

     public void run() {

         while(!cancelled){

             System.out.println("VolatileThread");

         }

         System.out.println("thread stop by volatile variable");

     }

     public void cancel() { cancelled = true; }

 }

1.3.2 中断+轮询

 //中断+轮询安全终止线程

 class InterruptThread implements Runnable{

     @Override

     public void run() {

         while(!Thread.currentThread().isInterrupted()){

             System.out.println("InterruptThread");

         }

         System.out.println("thread stop by interrupt thread");

     }

 }

1.4 线程通信

1.4.1 等待通知机制

等待/通知经典范式:

等待方遵循如下原则。

获取对象锁
如果条件不满足，调用对象wait方法,被通知后仍要检查条件
条件满足则执行对应的逻辑

synchronized (对象){

while(条件不满足){

对象.wait();

}

对应的处理逻辑;

}

通知方遵循如下原则:

获得对象的锁。
改变条件。
通知所有等待在对象上的线程。

synchronized (对象){

改变条件;

对象.notifyAll();

}

用法示例:

 /**

  * 线程通信，等待/通知机制

  */

 public class ThreadCommunication {

     public static void main(String[] args) {

         final Object lock = new Object();

         new Thread(new Runnable() {

             @Override

             public void run() {

                 System.out.println("thread A is waiting to get lock");

                 synchronized (lock) {

                     try {

                         System.out.println("thread A get lock");

                         TimeUnit.SECONDS.sleep(1);

                         System.out.println("thread A do wait method");

                         lock.wait();

                         System.out.println("thread A wait end");

                     } catch (InterruptedException e) {

                         e.printStackTrace();

                     }

                 }

             }

         }).start();

         new Thread(new Runnable() {

             @Override

             public void run() {

                 System.out.println("thread B is waiting to get lock");

                 synchronized (lock) {

                     System.out.println("thread B get lock");

                     try {

                         TimeUnit.SECONDS.sleep(5);

                     } catch (InterruptedException e) {

                         e.printStackTrace();

                     }

                     lock.notify();

                     System.out.println("thread B do notify method");

                 }

             }

         }).start();

     }

 }

wait能让当前线程阻塞，并释放拥有此对象的monitor(锁),当notify或者notifyAll被调用时,一个或所有线程被唤醒去竞争锁，调用notify/notifyAll方法的线程不会立即释放锁,只有当主动释放锁时，其它被唤醒的线程才能获得锁。

1.4.2 wait/notify底层实现

wait/notify都是native方法，底层是c++实现。每一对象都对应一个ObjectMonitor对象(synchronized重量级锁,对象头会保存指向ObjectMonitor对象的指针),ObjectMonitor对象如下图,有两个队列分别为_WaitSet和_EntryList,用来保存ObjectWaiter对象列表，处于wait状态的线程，会被加入到wait set,处于等待锁block状态的线程，会被加入到entry set。_owner指向获得ObjectMonitor的线程。在调用某一对象的wait或notify方法前,需对这一对象加synchronized锁,加锁成功的线程会设置ObjectMonitor对象的_owner指针。当加锁成功但调用对象的wait方法,会将线程封装成ObjectWaiter对象,并放入_WaitSet队列,线程调用park方法阻塞。当对象调用notify时,会将_WaitSet头节点移入_EntryList。当锁被释放时,会调用_EntryList中线程的unpark方法竞争锁。

图1.5 ObjectMonitor对象结构

二 java线程常用方法含义及原理

2.1 daemon线程

daemon线程主要用作程序中后台调度以及支持性工作,Thread.setDaemon(true)将线程设置为守护线程，当java虚拟机不存在非Daemon线程的时候,java虚拟机将会退出。虚拟机退出时,Daemon线程会立即终止,不能依靠finally块中的内容来确保关闭或清理资源。

2.2 join方法

thread.join()方法,会等待其它线程thread执行完，继续执行当前线程。join方法源码如下:

 public final synchronized void join(long millis)

 throws InterruptedException {

     long base = System.currentTimeMillis();

     long now = 0;

     if (millis < 0) {

         throw new IllegalArgumentException("timeout value is negative");

     }

     if (millis == 0) {

         while (isAlive()) {

             wait(0);

         }

     } else {

         while (isAlive()) {

             long delay = millis - now;

             if (delay <= 0) {

                 break;

             }

             wait(delay);

             now = System.currentTimeMillis() - base;

         }

     }

 }

Thread.join()方法通过wait/notify模式实现,调用join方法,线程对象最终会调用wait阻塞。线程执行完,会调用notify方法唤醒。

2.3 sleep()方法

sleep方法是native方法,其最终是利用内核提供的sleep系统调用实现。linux中的sleep()大致流程如下：

 #include <stdio.h>

 #include <stdlib.h>

 #include <signal.h>

 #include <unistd.h>

 ///时钟编程 alarm()

 void wakeUp()

 {

 printf("please wakeup!!/n");

 }

 int main(void)

 {

 printf("you have 4 s sleep!/n");

 signal(SIGALRM,wakeUp);

 alarm();

 //将进程挂起

 pause();

 printf("good morning!/n");

 return EXIT_SUCCESS;

 }

linux中的sleep,利用进程信号通信,注册信号SIGALRM的信号处理函数，并调用alarm设置定时器，接着调用pause()将进程挂起，将进程状态改为挂起状态，内核会重新分配CPU时间片，当alarm设置的时间到达时，操作系统会发送SIGALRM信号,此挂起的进程会执行WarkUp信号处理函数,pause函数会在进程捕捉到信号，并进行信号处理后返回。

2.4 yield()方法

yield方法是native方法，最终调用Linux内核的sched_yield系统调用，它会使当前线程放弃CPU使用权，加入同等优先级队列的队尾，和其它线程一起重新竞争CPU。sleep当传入参数为0时，和yield相同。

wait、sleep、yield都会让当前线程暂停执行,但使用场景、方式和原理各不相同。wait方法用于线程间通信,使用wait方法需先获得对象的锁,wait会释放线程拥有的锁;sleep方法用于短时间暂停当前线程,无强制要求必须先获取对象锁,且sleep不会释放线程拥有的锁。yield只是出让CPU使用权,让线程进入就绪调度队列重新调度，可能马上又重新获取CPU运行。

2.5 ThreadLocal用法及源码解析

ThreadLocal为变量在每个线程中都创建了一个副本，每个线程可以访问自己内部的副本变量,而不会出现冲突的问题,但由于每个线程都会有一个变量的副本，会导致消耗的内存变多。ThreadLocal类的get方法源码如下:

 public T get() {

     Thread t = Thread.currentThread();

     ThreadLocalMap map = getMap(t);//返回线程内部变量t.threadLocals

     if (map != null) {

         ThreadLocalMap.Entry e = map.getEntry(this);

         if (e != null) {

             @SuppressWarnings("unchecked")

             T result = (T)e.value;

             return result;

         }

     }

     return setInitialValue();//调用t.threadLocals = new ThreadLocalMap(this, firstValue);

 }

get方法会获得当前线程的map结构,map不为空,则以ThreadLocal变量为健,获取此变量的值,当ThreadLocalMap变量为空时，则会为线程创建一个ThreadLocalMap变量,可以看到,每个线程都有一个map的结构,当访问ThreadLocal变量时，会去当前访问线程的线程栈中取各自的threadLocalsb变量,从而达到多线程副本的目的。

秒客网