java并发基础及原理

时间:2021-09-28 22:34:13

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六种状态,线程状态间可以转换,状态转换图如下:
java并发基础及原理
图1.1 java线程状态转换图
  当进程出现问题时,可查看进程各线程的运行状况。
  1. ps -aux | grep java查看进程pid,如图1.2。
  2. top -Hp pid,查看进程各线程cpu、内存等占用情况,如图1.3。
  3. jstack pid,查看进程各线程的堆栈信息,包括运行状态等,如图1.4。
java并发基础及原理
图1.2 查找进程pid
 
java并发基础及原理
图1.3 查看进程各线程资源占用
 
java并发基础及原理
图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方法竞争锁。
java并发基础及原理
图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变量,从而达到多线程副本的目的。

参考文献

  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.