【Java基础】线程相关基础知识

一、相关概念

1.1 cpu

中央处理器(central processing unit, 简称cpu ),计算机系统的 运算 和 控制 核心

1.2 cpu核心数和线程数

cpu核心数指cpu 内核数量,如双核、四核、八核。

cpu线程数是一种逻辑的概念,就是模拟出的cpu核心数,

核心数:线程数=1:1

使用了超线程技术后---> 1:2

时间片:分配给线程的运行时间(进程允许运行的时间),通常为 10~100ms 。

1.3 CPU时间片轮转机制

又称RR调度,用于分时系统中的进程调度。

为了实现轮转调度,系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。 每当执行进程调度时,进程调度程序总是选出就绪队列的队首进程,让它在 CPU 上运行一个时间片的时间。

当进程用完分给它的时间片后,系统的计时器发出时钟中断,调度程序便停止该进程的运行,把它放入就绪队列的末尾; 然后,把 CPU 分给就绪队列的队首进程,同样也让它运行一个时间片, 如此往复。 会导致上下文切换。

1.4 进程和线程

  • 进程

        程序运行资源分配的最小单位,进程内部有多个线程,会共享这个进程的资源

  • 线程

        CPU调度的最小单位,必须依赖进程而存在。

1.5 进程和线程的区别

  • 从属关系:进程是正在运行程序的实例,进程包含了线程。
  • 描述侧重点:进程是操作系统分配资源的基本单位,线程是操作系统调度的基本单位。
  • 共享资源:多个进程不能共享资源,每个进程有自己的堆、栈、虚拟空间、文件描述等,而线程可以共享堆、方法。
  • 上下文切换速度:进程比较快(从一个线程切换到另一个线程),线程会比较慢。
  • 操作者:一般来说进程由系统控制,线程由程序员控制。

1.6 并行和并发

  • 并行

同一时刻,可以同时处理事情的能力。

并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。

  • 并发

与单位时间相关,在单位时间内可以处理事情的能力。

并发是指一个处理器同时处理多个任务。

打个比方:并发是一个人同时吃三个馒头,而并行是三个人同时吃三个馒头。

1.7 高并发的意义和注意事项

  • 意义

充分利用cpu的资源、加快用户响应的时间,程序模块化,异步化

  • 注意事项
    • 线程共享资源,存在冲突
    • 容易导致死锁
    • 启用太多的线程,就有搞垮机器的可能

1.8 线程的优先级

取值为1~10,缺省为5,但线程的优先级不可靠,不建议作为线程开发时候的手段

1.9 守护线程 & 用户线程

  • User Thread(用户线程)

普通线程,例如普通当new Thread

  • Daemon Thread(守护线程)

thread1.setDaemon(true); 也即设置了 setDaemon的线程

1.守护线程并非虚拟机内部可以提供,用户也可以自行的设定守护线程,方法:public final void setDaemon(boolean on)

2.thread.setDaemon(true)必须在thread.start()之前设置,否则会跑出一个IllegalThreadStateException异常。

3.你不能把正在运行的常规线程设置为守护线程。

4.守护线程中创建当线程也是守护线程。

当 JVM 中不存在任何一个正在运行的非守护线程时,则 JVM 进程即会退出, 大白话就是当主线程结束时,此时普通当用户线程会继续执行,

当所有当用户线程执行完后,即结束所有线程,此时如果还有守护线程在执行,也会立即结束。

1.10 为什么需要多线程

CPU、内存、I/O 设备的速度是有极大差异的,为了合理利用 CPU 的高性能,平衡这三者的速度差异。

  • CPU 增加了缓存,以均衡与内存的速度差异;// 导致 可见性问题
  • 操作系统增加了进程、线程,以分时复用 CPU,进而均衡 CPU 与 I/O 设备的速度差异;// 导致 原子性问题
  • 编译程序优化指令执行次序,使得缓存能够得到更加合理地利用。// 导致 有序性问题

1.11 并发出现问题的根源: 并发三要素

可见性是由于CPU缓存引起。

可见性:一个线程对共享变量的修改,另外一个线程能够立刻看到。如:

//线程1执行的代码

int i = 0;

i = 10;

//线程2执行的代码

j = i;

假若执行线程1的是CPU1,执行线程2的是CPU2。由上面的分析可知,当线程1执行 i =10这句时,会先把i的初始值加载到CPU1的高速缓存中,然后赋值为10,那么在CPU1的高速缓存当中i的值变为10了,却没有立即写入到主存当中。

此时线程2执行 j = i,它会先去主存读取i的值并加载到CPU2的缓存当中,注意此时内存当中i的值还是0,那么就会使得j的值为0,而不是10.

原子性问题是分时复用引起。

原子性:即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行。

如:

int i = 1;

// 线程1执行

  i += 1;

// 线程2执行

  i += 1;

1. 将变量 i 从内存读取到 CPU寄存器;

2. 在CPU寄存器中执行 i + 1 操作;

3. 将最后的结果i写入内存(缓存机制导致可能写入的是 CPU 缓存而不是内存)。

由于CPU分时复用(线程切换)的存在,线程1执行了第一条指令后,就切换到线程2执行,假如线程2执行了这三条指令后,再切换会线程1执行后续两条指令,将造成最后写到内存中的i值是2而不是3。

有序性问题是重排序引起。

int i = 0;

boolean flag = false;

i = 1; //语句1

flag = true; //语句2

二、线程状态

1. 新建状态(New): 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。

2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,其它线程调用了该对象的start()方法,从而来启动该线程。 例如,thread.start()。处于就绪状态的线程,随时可能被CPU调度执行。

3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是,线程只能从就绪状态进入到运行状态

4. 阻塞状态(Blocked): 阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。

阻塞的情况分三种:

- 等待阻塞 > 通过调用线程的wait()方法,让线程等待某工作的完成。

- 同步阻塞 > 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态。

- 其他阻塞 > 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

5. 死亡状态(Dead): 线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

6.Waiting等待状态

【Java基础】线程相关基础知识_第1张图片

三、线程创建 停止方式

3.1 线程创建

从JDK 5开始,把工作单元与执行机制分离开来,工作单元包括Runnable和Callable,而执行机制由Executor框架提供。

3.1.1 extends Thread。

由于java的单继承性,此类不可再继承其他类, 若使用runnable的方式,则可多继承,且runnable 可被多个thread共享

ExThread thread1 = new ExThread("thread1");
thread1.start();

thread 类本身就是实现runnable接口

public class Thread implements Runnable {
}

3.1.2 implements Runnable

run()方法,本质还是通过new Thread实现。好处是多继承,且可资源共享。

3.1.3 implements Callable

call()方法,通过FutureTask实例对象的get方法获取执行结果。

通过callable、FutureTask、thread组合, FutureTask也实现类runnable接口。

ImplCallable callable = new ImplCallable("thread3");
FutureTask task = new FutureTask<>(callable);
Thread thread1 = new Thread(task);
thread1.start();

3.1.4 通过线程池方式创建好线程

事先将多个线程对象放到一个容器中,当使用的时候就不用 new 线程而是直接去池中拿线程即可,节省了开辟子线程的时间,提高的代码执行效率。 所以总结起来应该就只有new thread一种方式,

Runnable和Callable区别

Callable的 call() 方法可以返回值和抛出异常,而Runnable的run()方法没有这些功能,run的异常只能内部消化。

这两个接口最后都需要调用thread.start()方法。

FutureTask在调用get()方法时会阻塞主线程,反之,线程不会阻塞。

runnable没有返回值,而实现callable接口的任务线程能返回执行结果。

callable接口实现类中的run方法允许异常向上抛出,可以在内部处理,try catch; 但是runnable接口实现类中run方法的异常必须在内部处理,不能抛出。

public interface Callable V> {
    V call() throws Exception;
}
public interface Runnable {
    public abstract void run();
}

thread的start()和run()方法有什么区别

start()方法被用来启动新创建的线程,而且start()内部调用了run()方法 ,

用start方法来启动线程,真正启动来一个新的线程,在start方法调用后,会继续执行下面的代码,例如: 下面start方法调用后,会立马执行后面的日志输出

thread1.start();

Log.d("xyz", "threadName");

调用start方法后,此时线程处于就绪状态,并没有真正运行,线程被放到操作系统的任务等待队列,等待cpu调度,然后通过jvm,最后会调用到thread的run方法。

调用run()方法的时候,只会是在原来的线程中调用,没有新的线程启动,

start()方法会启动新线程,当一个线程启动之后,不能重复调用start(),否则会报IllegalStateException异常。

run方法就是一个普通的方法,如果直接调用,就是运行在调用的线程中。

线程是不是越多越好

CPU密集型任务,并行执行的线程数应该尽量和CPU核心数保持一致,否则超过了CPU核心数,再提高线程数也不会提高处理速度,反而因为上下文切换带来的损耗降低处理速度。对于I/O密集型任务,根据I/O的响应速度,适当地调节线程数目,可以提高系统速度。

3.2 线程停止

java线程的终止,可以让线程运行完自动终止,也可以在运行过程中主动停止,通过添加退出标记。

new Thread(new Runnable() {
    private volatile boolean exit=false;
        @Override
        public void run() {
            while(!exit){
            //执行业务逻辑
            }
    }
}).start();

java线程是协作式,而非抢占式。

你可能感兴趣的:(java基础,jvm,java,面试,线程)