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线程状态转换图

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

1.   ps -aux | grep java查看进程pid,如图1.2。
2.   top -Hp pid,查看进程各线程cpu、内存等占用情况，如图1.3。
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 等待通知机制

等待/通知经典范式:

等待方遵循如下原则。

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

synchronized (对象){

    while(条件不满足){

        对象.wait();

    }

    对应的处理逻辑;

}

通知方遵循如下原则:

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

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(4);
//将进程挂起
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变量,从而达到多线程副本的目的。

参考文献

1. Java并发学习之四种线程创建方式的实现与对比.
2. 如何使用jstack分析线程状态.
3. 如何安全地终止线程？
4. Java 并发：线程间通信与协作.
5. JVM源码分析之Object.wait/notify实现.
6. sleep实现原理.
7. pause()函数.
8. Java中Wait、Sleep和Yield方法的区别.
9. Java线程源码解析之yield和sleep.
10. Java并发编程：深入剖析ThreadLocal.