【Java并发编程】Java多线程(一):线程基础

发布于 2020-9-18 10:29
浏览
1收藏

1.线程介绍

 

1.1 线程状态

 

NEW(创建):线程刚被创建,但未启动,还未调用start
RUNNABLE(可运行):调用了 strat 方法;可能在CPU执行,也有可能没有
TIMED_WAITING(计时等待):让出CPU,计时休眠;sleep(持锁)
WAITINIT(等待):让出CPU,休眠;无锁park->unpark,有锁wait->notify(会释放锁)
BLOCKED(阻塞):等待获得 monitor lock 锁,是对于 synchronized 而言
TERMINATED(终止):运行结束;子线程运行完成、被打断、被中止

 

下图是进程状态与Java线程状态对比:

 【Java并发编程】Java多线程(一):线程基础-开源基础软件社区

1.2 优先级


优先级代表线程执行的机会的大小,优先级高的可能先执行,低的可能后执行,在 Java 源码中,优先级从低到高分别是 1 到 10,线程默认 new 出来的优先级都是 5,源码如下:

// 最低优先级
public final static int MIN_PRIORITY = 1; 

// 普通优先级,也是默认的
public final static int NORM_PRIORITY = 5;

// 最大优先级
public final static int MAX_PRIORITY = 10;

 

1.3 守护线程


我们默认创建的线程都是非守护线程。创建守护线程时,需要将 Thread 的 daemon 属性设置成 true,守护线程的优先级很低,当 JVM 退出时,是不关心有无守护线程的,即使还有很多守护线程,JVM 仍然会退出,我们在工作中,可能会写一些工具做一些监控的工作,这时我们都是用守护子线程去做,这样即使监控抛出异常,但因为是子线程,所以也不会影响到业务主线程,因为是守护线程,所以 JVM 也无需关注监控是否正在运行,该退出就退出,所以对业务不会产生任何影响。

 

1.4 几点注意

 

线程是交替运行的(任务>时间片),现在CPU往往多核
main是主线程,可能提前执行完成一般不要阻塞
线程间相互独立,当有异常抛出时,只会影响当前线程
Thread.currentThread()当前线程


2.*线程创建 & 运行

 

**线程相当于载体,要start必须要有任务(Callable/Runnable) **

 

2.1 Thread

 

为了方便,Thread已经实现了Runnable,因此可以直接继承Thread,并重写run方法

class MyThread extends Thread{
  public void run() {...}
}

 

2.2 Runnable

// 内部类
Thread thread = new Thread(new Runnable() {
  public void run() {...}
});

// lamada
new Thread(()->{
    public void run() {...}
}).start()

 

2.3 Callable

// Callable不能直接使用,而是包装成FutureTask 
FutureTask futureTask = new FutureTask(new Callable<T> () {
    public String call() throws Exception {...}
  });
// FutureTask也是Runnable,所以可以传入Thread然后运行
new Thread(futureTask).start();
// 获取执行结果,无参会一直阻塞等待执行结果
futureTask.get()


-> start方法源码


start 方法可以创建一个新的线程出来,内部就是调用Runnable的run方法

public synchronized void start() {
    // 如果没有初始化,抛异常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    // started 是个标识符,我们在做一些事情的时候,经常这么写
    // 动作发生之前标识符是 false,发生完成之后变成 true
    boolean started = false;
    try {
        // 这里会创建一个新的线程,执行完成之后,新的线程已经在运行了,既 target 的内容已经在运行了
        start0();
        // 这里执行的还是主线程
        started = true;
    } finally {
        try {
            // 如果失败,把线程从线程组中删除
            if (!started) {
                group.threadStartFailed(this);
            }
         // Throwable 可以捕捉一些 Exception 捕捉不到的异常,比如说子线程抛出的异常
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}
// 开启新线程使用的是 native 方法
private native void start0();

 

3.线程控制


3.1 Thread.sleep

 

线程进入Timed_Waiting,当前线程休眠,释放CPU,持锁等待

 

作用

模拟任务;防止多线程下任务<时间片,线程串行执行
暂停线程;在线程运行期间将其暂停,让其余线程运行

 

TimeUnit.SECONDS.sleep(2)

 

3.2 Thread.yeild


当前线程让出CPU,进入NEW状态,再次去竞争CPU

 

作用:防止当前线程一直占用CPU

 

与sleep的区别

sleep可以指定等待时间
sleep这段时间各个级别的线程都可运行,yeild一般只能让优先级高的线程运行

 

3.3 Thread.interrput

 

设置线程中断不影响线程的继续执行
但是线程设置休眠后(wait、jion、sleep), 抛出 InterruptedException,且中断标志被清除,重新设置为false
Thread.currentThread().isInterrupted()

 

3.4 obj.wait


线程进入WAITING,释放当前对象的锁,等待被唤醒

 

必须在synchronized代码块内使用,要先持有锁

本质:Java的线程通信实质上是共享内存,而不是直接通信
表象:wait,notify需要调用monitor对象

 

一般配合while使用

被唤醒后会重新竞争锁,之后从上次wait位置重新运行
while多次判断,防止在wait这段时间内对象被修改

 

3.5 obj.notify(All)

 

随机唤醒wait的线程
必须在synchronized代码块中使用
等当前线程运行完释放锁后,唤醒的线程再重新竞争锁
在生产者消费者模型中,推荐使用notifyAll,因为notify唤醒的线程不确定是生产者或消费者


3.6 obj.join

 

当前线程会等待调用join的线程结束后,再继续运行
本质:其实就是当前线程功能wait,调用线程运行完后notify

 

作用

当线程任务量大时,保证main线程在这些线程运行结束后再结束、
可控制子线程间执行顺序

 

3.7 LockSupport.park

 

使指定线程在没获得锁的情况下进入WAITING,休眠释放CPU
需要unpark指定唤醒线程


区别对比:

wait:unpark(th)可以唤醒指定线程,而notify是随机唤醒
yeild:park进入休眠状态不再抢占CPU,而yeild只是让出并参与下一次CPU竞争
interrput:interrput在线程休眠前不会影响线程执行


park是定义UNSAFE中的,一般通过LockSupport调用

 

 

 

作者:A minor

来源:CSDN

标签
收藏 1
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐