1.1什么是线程?
在理解线程之前先要明白什么是进程,因为线程是进程中的一个实体。(线程是不会独立存在的)
进程:是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,线程则是进程中的一个执行路径,一个进程中至少会有一个线程,进程中的多个线程共享进程的资源。
线程:是cpu分配的基本单位。
由上图可看出,一个进程中会有多个线程,多个线程共享堆和方法区,但是每一个线程都会有自己的栈和程序计数器。
为什么要将栈和程序计数器设置为线程私有的呢? 前边说线程是cpu执行的基本单位,而cpu一般是使用时间片轮转方式轮询占用的,所以当当前线程cpu时间片使用完毕后,要让出cpu,等待下一次轮到自己的时候在调用。 那问题就来了,线程是如何知道之前执行到哪了? 程序计数器就是为了记录之前让出cpu时执行到的地址,等下次再次执行时就可以从程序计数器中获取之前执行到的位置,继续向下执行。(程序计数器是不会记录native方法执行的地址的,它只记录java代码执行的地址),而栈则是存储现场的局部变量,一遍之后再次使用
1.2线程的创建和运行
三种方式:继承Thread、实现Runnable接口、使用FuthreTask方式(实现Callable接口)。
package com.nxz.blog.otherTest; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class TestThread { static class MyThread1 extends Thread { @Override public void run() { System.out.println("extend-Thread:"+this.getName()); } } static class MyThread2 implements Runnable { @Override public void run() { System.out.println("implements-Runnable:"+Thread.currentThread()); } } static class MyThread3 implements Callable<String> { @Override public String call() throws Exception { System.out.println("implements-Callable:"+Thread.currentThread()); return "Callable接口"; } } public static void main(String[] args) { MyThread1 t1 = new MyThread1(); t1.start(); Thread t2 = new Thread(new MyThread2()); t2.start(); FutureTask<String> futureTask = new FutureTask<>(new MyThread3()); new Thread(futureTask).start(); try { // 阻塞,等待执行完毕,并返回结果 String res = futureTask.get(); System.out.println(res); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } System.out.println("main-Thread"); } }
上述代码执行结果:
extend-Thread:Thread-0 implements-Runnable:Thread[Thread-1,5,main] implements-Callable:Thread[Thread-2,5,main] Callable接口 main-Thread
创建线程后会调用start方法,代表当前线程已经处于就绪状态(也就是说该线程已经获取了除cpu资源外的其他资源,等待cpu执行时间片),当获取了cpu资源后,该线程才处于运行状态,一旦run方法(对于extent Thread来说)执行完毕,该线程就处于终止状态。
使用继承的好处:在run方法内可以直接使用this来获取当前线程(而另两个的this则没有getName等一些方法),而不需要Thread.currentThread()。
1.3线程通知和等待
以下三个方法都是Object类的方法,为所有对象公用
①wait()
当一个线程调用wait()方法后,该线程就会被阻塞挂起,知道被notify/notifyAll调用或者其他线程调用了intercept方法中断了该线程
②wait(long timeout)
表上边一个多了一个超时时间,在等待期间如果没有其他线程唤醒(notify/notifyAll)该线程,该线程仍然会在超过timeout时间后自动返回
③wait(long timeout, int nanos) :两个参数,毫秒timeout,纳秒nanos,其内部还是调用的wait(long timeout)方法,只不多对于第二个参数纳秒,如果其范围是大于0,小于一百万的话(1毫秒= 100 0000纳秒),则将timeout加一秒
public final void wait(long timeout, int nanos) throws InterruptedException { if (timeout < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (nanos < 0 || nanos > 999999) { throw new IllegalArgumentException( "nanosecond timeout value out of range"); } if (nanos > 0) { timeout++; } wait(timeout); }
④notify()/notifyAll()
唤醒在同一个共享变量上等待的线程,区别:一个唤醒一个,一个唤醒所有
需要注意的:
*虚假唤醒:
一个线程可以从挂起状态变为可以运行状态(也就是被唤醒),即使该线程没有被其他线程调用notify()、notifyAll()方法进行通知,或者被中断,或者等待超时,这就是虚假唤醒
(在java并发编程之美中这样描述的,感觉不太清楚,找了其他资料有的是这样描述的:在多核处理器下,其他线程的信号可能会唤醒多个线程(阻塞在同一个条件变量上的线程),结果就是,多个被唤醒的线程,前一个执行代码逻辑后,另外的线程再次执行同样的代码后会出现问题)
例子:在下边代码中分别为生产者和消费者,假如在一个生产者和一个消费者的情况下(也就是单线程),是没有问题的,不存在虚假唤醒,假如在多线程环境下,当一个生产者完成之后,调用notifyAll方法后,会唤醒其他生产者和所有的消费者,当第一个消费者消费完成之后,在有消费者消费,此时就会出现问题(也就是出现了虚假唤醒),解决该问题的方法,就是将消费者和生产者中的条件判断if(queue.size() == 1) 和if(queue.isEmpty()) 改为 while( queue.size() == 1) 和while( queue.isEmpty() ) ,即改为循环判断,当被唤醒是,每一个线程都重新判断是否符合条件
static Queue queue; static class ProductThread extends Thread { @Override public void run() { synchronized (queue) { if (queue.size() == 1) {// 假设队列最多存一个对象 try { queue.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } queue.add(new Object()); queue.notifyAll(); } } } static class ConsumerThread extends Thread { @Override public void run() { synchronized (queue) { if (queue.isEmpty()) { try { queue.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } queue.poll(); queue.notifyAll(); } } }
1.4等待线程执行完毕 的join方法
当调用join方法(该方法属于Thread类)时,就会等待线程执行完毕后,在继续向下运行
例子:
package com.nxz.blog.otherTest; public class TestThread002 { static class MyThread extends Thread{ @Override public void run() { System.out.println("myThread"); } } public static void main(String[] args) throws InterruptedException { MyThread t1 = new MyThread(); t1.setName("myThread"); t1.start(); // 如果注释掉 下边代码的话,main方法的输出应该会是 先main-thread 然后再试mythread, // 放开的话 main主线程就会等待t1线程执行完毕后,在向下运行 t1.join(); System.out.println("main-thread"); } }
1.5sleep方法休眠
Thread中的静态方法sleep(),当一个线程调用了sleep方法后,会短暂的让出cpu执行权(也就是不参与cpu的调度),但是线程拥有的锁等资源是不释放的,这一点和wait方法不同
1.6让出cpu执行权yield方法
Thread中的静态方法yield(),当一个线程调用了Thread.yield()时,表名当前线程放弃cpu的使用权,yield之后,当前线程处于就绪状态。线程调度器会从包括该线程的所有线程中随机选出一个线程分配cpu执行时间片。
1.7中断线程
java中的线程中断是一种线程间的协作模式,通过设置线程的中断标志并不能直接中断线程,而是被中断的线程根据中断标志自行处理。
void interruupt() :中断线程
boolean isInterrupted() :检测当前现车鞥是否中断(调用isInterrupted()方法的实例的中断标志)
boolean interrupted(): 检测当前线程是否被中断(内部是获取当前线程的中断标志而不是调用interruupted()方法的实例的中断标志)
1.8线程的上下文切换
在多线程编程中线程的个数一般都是大于cpu的个数的,而每个cpu在同一时刻只能被一个线程使用。为了让用户感觉实在同时执行,cpu资源的分配采用时间片轮询的侧率。
上下文切换:就是一个线程使用完时间片之后,将cpu资源让给其他线程使用,并且线程状态转变为就绪状态。
1.9线程死锁
多个线程在执行过程中,因争夺资源而造成相互等待的状态,如没有其他因素,线程会一直等待,而无法继续运行。
死锁产生的条件:1、互斥 2、请求并持有资源 3、不可剥夺 4、环路等待
1.10守护线程和用户线程
守护线程:类似垃圾回收线程
用户线程:main函数启动,就是一个简单的用户线程
jvm停止的时机:在用户线程全都执行完毕后,jvm就会停止(无论有没有守护线程)
1.11ThreadLocal
当创建了一个ThreadLocal变量之后,多个线程操作这个变量时,实际上操作的是自己本地内存里的变量,也就是说每个线程都会复制一份变量到自己的本地内存。
THreadLocal是怎么和线程关联起来的呢?
ThreadLocal其实就是一个空壳,当调用ThreadLocal的set或get方法时,其内部是通过set方法把value放到调用线程的threadlocals变量中(ThreadLocal.threadLocalMap),也就是说本地变量不是存在ThreadLocal实例中,而是存入Thread中的threadlocals中。
public void set(T value) { Thread t = Thread.currentThread(); // 当调用ThreadLocal的set方法时,其实是获取的是当前线程Thread中的ThreadLocalMap变量,如果变量为null,则新建一个ThreadLocalMap,如果变量存在,则之间将当前线程和value存入定制的map中(ThreadLocalMap) ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); } // 从源码getMap中可以看出,其实获取的是当前线程中的threadLocals变量 ThreadLocalMap getMap(Thread t) { return t.threadLocals; } void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); }
public T get() { // ThreadLocal的get方法,同样是获取的是当前线程Thread中的threadLocals变量(也就是ThreadLocalMap类型的数据) Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue(); }
原文地址:https://www.cnblogs.com/nxzblogs/p/11318671.html