进程是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,线程则是进程的一个执行路径,一个进程中至少有一个线程,进程中的多个线程 共享进程的资源 。
操作系统在分配资源时是把资源分配给进程的,但是CPU资源比较特殊,它是被分配到线程的,因为真正要占用CPU运行的是线程,所以也说 线程是CPU分配的基本单位 。
以Java 为例,我们启动一个main函数时,实际上就是启动了一个 JVM 的进程 , main函数 所在的线程就是这个进程的一个线程,也称为 主线程 。一个JVM进程中有多个线程, 多个线程共享进程的堆和方法区资源,但是每个线程有自己的程序计数器和栈区域 。
Java 线程创建有3种方式:
继承 Thread
类并且重写 run
方法
实现 Runnable
接口的 run
方法
使用 FutureTask
方式
具体代码示例不详述,太基础,会感觉在水。
说下 FutureTask 的方式,这种方式的本事也是实现了Runnable 接口的 run 方法,看它的继承结构就可以知道。
前两种方式都没办法拿到任务的返回结果,但是 Futuretask 方式可以。
wait() 方法的效果就是 该调用线程被阻塞挂起 ,直到发生以下几种情况才会调起:
其他线程调用了该共享对象的 notify() 方法或者 notifyAll() 方法(继续往下走)
其他线程调用了该线程的 interrupt() 方法,该线程会 InterruptedException 异常返回
如果调用 wait() 方法的线程没有事先 获取该对象的监视器锁 ,调用线程会抛出IllegalMonitorStateException 异常。 当线程调用wait() 之后,就已经释放了该对象的监视器锁 。
执行synchronized 同步代码块,使用 该共享变量 作为参数。
synchronized(共享变量) { // TODO }
调用该共享变量的同步方法(synchronized 修饰)
synchronized void sum(int a, int b) { // TODO }
一个线程调用共享对象的 notify() 方法后,会唤醒一个在该共享变量上调用 wait(...) 系列方法后被挂起的线程。
值得注意的是:
notifyAll() 方法则会 唤醒所有 在该共享变量上由于调用wait系列方法而被挂起的线程。
比较经典的就是生产者和消费者的例子
public class NotifyWaitDemo { public static final int MAX_SIZE = 1024; // 共享变量 public static Queue queue = new Queue(); public static void main(String[] args) { // 生产者 Thread producer = new Thread(() -> { synchronized (queue) { while (true) { // 挂起当前线程(生产者线程) // 并且,释放通过queue的监视器锁,让消费者对象获取到锁,执行消费逻辑 if (queue.size() == MAX_SIZE) { try { queue.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } // 空闲则生成元素,并且通知消费线程 queue.add(); queue.notifyAll(); } } }); // 消费者 Thread consumer = new Thread(() -> { synchronized (queue) { while (true) { // 挂起当前线程(消费者线程) // 并且,释放通过queue的监视器锁,让生产者对象获取到锁,执行生产逻辑 if (queue.size() == 0) { try { queue.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } // 空闲则消费元素,并且通知生产线程 queue.take(); queue.notifyAll(); } } }); producer.start(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } consumer.start(); } static class Queue { private int size = 0; public int size() { return this.size; } public void add() { // TODO size++; System.out.println("执行add 操作,current size: " + size); } public void take() { // TODO size--; System.out.println("执行take 操作,current size: " + size); } } }
由于Thread类继承了Object类,所以Thread也可以调用者三个方法,等待和唤醒必须是同一个锁。而锁可以是任意对象,所以可以被任意对象调用的方法是定义在object类中。
适用场景:需要等待某几件事情完成后才能继续往下执行,比如多个线程加载资源,需要等待多个线程全部加载完毕再汇总处理。
public static void main(String[] args){ ... thread1.join(); thread2.join(); System.out.println("all child thread over!"); }
主线程首先会在调用thread1.join() 后被阻塞,等待thread1执行完毕后,thread2开始阻塞,以此类推,最终会等所有子线程都结束后main函数才会返回。如果其他线程调用了被阻塞线程的 interrupt() 方法,被阻塞线程会抛出 InterruptedException 异常而返回。
sleep()会使线程暂时让出指定时间的执行权,也就是 在这期间不参与CPU的调度 , 但不会释放锁 。
指定的睡眠时间到了后该函数会正常返回,线程就处于就绪状态,然后参与CPU的调度,获取到CPU资源后就可以继续运行了。
如果在睡眠期间其他线程调用了该线程的 interrupt() 方法中断了该线程,则该线程会在调用sleep方法的地方抛出 InterruptedException 异常而返回。
/** * 帮助理解 sleep 不会让出监视器资源 * * 在线程A睡眠的这10s内那个独占锁lock还是线程A自己持有 * 线程B会一直阻塞直到线程A醒来后执行unlock释放锁。 */ public class ThreadSleepDemo { // 独占锁 private static final Lock LOCK = new ReentrantLock(); public static void main(String[] args) { Thread threadA = new Thread(() -> { // 获取独占锁 LOCK.lock(); try { System.out.println("child thread A is in sleep"); Thread.sleep(10000); System.out.println("child thread A is awake"); } catch (InterruptedException e) { e.printStackTrace(); } finally { // release lock LOCK.unlock(); } }); Thread threadB = new Thread(() -> { // 获取独占锁 LOCK.lock(); try { System.out.println("child thread B is in sleep"); Thread.sleep(10000); System.out.println("child thread B is awake"); } catch (InterruptedException e) { e.printStackTrace(); } finally { // release lock LOCK.unlock(); } }); threadA.start(); threadB.start(); } }
线程调用yield 方法时,实际上是 暗示线程调度器当前线程请求让出自己的CPU使用 (告诉线程调度器可以进行下一轮的线程调度),但 线程调度器可以无条件忽略这个暗示 。
我们知道 操作系统是为每个线程分配一个时间片来占有CPU的 ,正常情况下当一个线程把分配给自己的时间片使用完后,线程调度器才会进行下一轮的线程调度,而当一个线程调用了Thread类的静态方法 yield 时,是在告诉线程调度器自己占有的时间片中还没有使用完的部分自己不想使用了,这暗示线程调度器现在就可以进行下一轮的线程调度。
一般很少使用这个方法 ,在调试或者测试时这个方法或许可以帮助复现由于并发竞争条件导致的问题,其在设计并发控制时或许会有用途,在java.util.concurrent.locks包里面的锁时会看到该方法的使用
sleep与yield方法的区别在于:当线程调用sleep方法时调用线程会被阻塞挂起指定的时间,在这期间线程调度器不会去调度该线程。而调用yield 方法时,线程只是让出自己剩余的时间片, 并没有被阻塞挂起,而是处于就绪状态 ,线程调度器下一次调度时就有可能调度到当前线程执行。
Java中的线程中断是一种线程间的协作模式, 通过设置线程的中断标志并不能直接终止该线程的执行,而是被中断的线程根据中断状态自行处理 。
设置线程的中断标志为true并立即返回, 但线程实际上并没有被中断而会继续向下执行 ;如果线程因为调用了wait系列函数、join方法或者sleep方法而被阻塞挂起,其他线程调用该线程的interrupt()方法会使该线程抛出InterruptedException异常而返回。
检测线程是否被中断,是则返回true,否则返回false。
public boolean isInterrupted() { // 传递 false 说明不清除中断标志 return isInterrupted(false); }
检测 当前线程 是否被中断,返回值同上 isInterrupted() , 不同的是,如果发现当前线程被中断,会清除中断标志 ;该方法是 static 方法,内部是获取 当前调用线程的中断标志而不是调用interrupted()方法的实例对象的中断标志 。
public static boolean interrupted() { // static 方法 // true - 清除终端标志 // currentThread return currentThread().isInterrupted(true); }
我们都知道,在多线程编程中,线程个数一般都大于CPU 个数,而每个CPU同一时刻只能被一个线程使用。
为了让用户感觉多个线程是在同时执行的,CPU资源的分配采用了 时间片轮转 的策略,也就是每个线程分配一个时间片,线程在时间片内占用CPU执行任务。当前线程使用完时间片后,就会处于就绪状态并且让出CPU让其他线程占用,这就是线程的 上下文切换 。
死锁是指两个或两个以上的线程在执行过程中,因争夺资源而造成的互相等待的现象,在无外力作用的情况下,这些线程会一直相互等待而无法继续运行下去。
就如上图,线程A持有资源2,同时想申请资源1,线程B持有资源1,同时想申请资源2,两个线程相互等待就形成了死锁状态。
死锁的产生有四个条件:
Java 线程分为两类,
在JVM 启动时会调用 main 函数,main 函数所在的线程就是一个用户线程,同时在JVM 内部也启动了很多守护线程,比如 GC 线程。
守护线程和用户线程的区别在于, 守护线程不会影响JVM 的退出,当最后一个用户线程结束时,JVM 会正常退出。
举例:比如在Tomcat 的NIO 实现 NioEndpoint
类中,会开启一组接受线程来接受用户的连接请求,以及一组处理线程负责具体处理用户请求。
/** * Start the NIO endpoint, creating acceptor, poller threads. */ @Override public void startInternal() throws Exception { if (!running) { // ... 省略 // Start poller threads 处理线程 pollers = new Poller[getPollerThreadCount()]; for (int i=0; i<pollers.length; i++) { pollers[i] = new Poller(); Thread pollerThread = new Thread(pollers[i], getName() + "-ClientPoller-"+i); pollerThread.setPriority(threadPriority); pollerThread.setDaemon(true); // pollerThread.start(); } // 启动接收线程 startAcceptorThreads(); } } protected final void startAcceptorThreads() { int count = getAcceptorThreadCount(); acceptors = new Acceptor[count]; for (int i = 0; i < count; i++) { acceptors[i] = createAcceptor(); String threadName = getName() + "-Acceptor-" + i; acceptors[i].setThreadName(threadName); Thread t = new Thread(acceptors[i], threadName); t.setPriority(getAcceptorThreadPriority()); t.setDaemon(getDaemon()); // 默认值是true t.start(); } }
在如上代码中,在默认情况下,接受线程和处理线程都是守护线程,这意味着当tomcat收到shutdown命令后并且没有其他用户线程存在的情况下tomcat进程会马上消亡,而不会等待处理线程处理完当前的请求。
本篇讲了有关Java 线程的一些基础知识。下一篇,我计划是写一下 Java 线程的生命周期、线程的各个状态和以及各个状态的流转 。因为关于这部分我感觉国内网站上大部分的文章都没有讲清楚,我会尝试用图片、文字和具体的代码结合的方式写一篇。有兴趣的小伙伴可以关注一下。
如果本文有帮助到你,希望能点个赞,这是对我的最大动力 。