1. 概念
1.1 进程和线程
- 进程是一个系统运行程序的基本单位,是资源申请、调度和独立运行的单位。
- 线程是进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。
- 线程又称为轻量级进程,它和进程一样拥有独立的执行控制,由操作系统负责调度,区别在于线程没有独立的存储空间,而是和所属进程中的其它线程共享一个存储空间,这使得线程间的通信远较进程简单。
- 线程优先级单核计算机只有一个CPU,各个线程轮流获得CPU的使用权,才能执行任务:
- 优先级较高的线程有更多获得CPU的机会,反之亦然。
- 优先级用整数表示,取值范围是1~10,一般情况下,线程的默认 优先级都是5,但是也可以通过setPriority和getPriority方法来设置或返回优先级。
1.2 生命周期
一个线程的生命周期如下图所示:包含七个状态
- 新建状态( NEW): 线程刚创建, 尚未启动。Thread thread = new Thread()。
- 可运行状态(RUNNABLE): 线程对象创建后,其他线程(比如 main 线程)调用了该对象的 start 方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取 cpu 的使用权。
- 运行(running): 线程获得 CPU 资源正在执行任务(run() 方法),此时除非此线程自动放弃 CPU 资源或者有优先级更高的线程进入,线程将一直运行到结束
- 阻塞状态(Blocked): 线程正在运行的时候,被暂停,通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend,wait等方法都可以导致线程阻塞
- 等待(WAITING): 进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
- 超时等待(TIMED_WAITING): 该状态不同于WAITING,它可以在指定的时间后自行返回。
- 终止(TERMINATED): 表示该线程已经执行完毕,如果一个线程的run方法执行结束或者调用stop方法后,该线程就会死亡。对于已经死亡的线程,无法再使用start方法令其进入就绪。
2. 多线程的使用
2.1 继承Runnable接口
实现Runnable接口,重载run(),无返回值,Runnable接口的存在主要是为了解决Java中不允许多继承的问题。
实现接口,也可以利用lamb表达式
public class ThreadRunnable implements Runnable{
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
创建线程
public static void main(String[] args) throws Exception {
ThreadRunnable threadRunnable1 = new ThreadRunnable();
ThreadRunnable threadRunnable2 = new ThreadRunnable();
ThreadRunnable threadRunnable3 = new ThreadRunnable();
Thread thread1 = new Thread(threadRunnable1);
Thread thread2 = new Thread(threadRunnable2);
Thread thread3 = new Thread(threadRunnable3);
Thread thread = new Thread(()->{
System.out.println("线程四 继承runable");
});
thread1.start();
thread2.start();
thread3.start();
thread.start();
}
2.2 继承Thread类
继承Thread类,重写run(),通过调用Thread的start()会调用创建线程的run(),不同线程的run方法里面的代码交替执行。但由于Java不支持多继承.因此继承Thread类就代表这个子类不能继承其他类.
public class ThreadCustom extends Thread {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread() + ":" + i);
}
}
}
public class ThreadTest {
public static void main(String[] args)
{
ThreadCustom thread = new ThreadCustom();
thread.start(); //子类会继承父类的start()方法
}
}
2.3 实现Callable接口
实现Callable接口,通过FutureTask/Future来创建有返回值的Thread线程,通过Executor执行,该方式有返回值,可以获得异步。
public class ThreadCallableCustom {
public static void main(String[] args) throws Exception {
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
public Integer call() throws Exception {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
return 1;
}
});
Executor executor = Executors.newFixedThreadPool(1);
((ExecutorService) executor).submit(futureTask);
//获得线程执行状态
System.out.println(Thread.currentThread().getName() + ":" + futureTask.get());
}
}
2.4 使用Executors
线程池创建的相关工具类,用来创建不同的线程池。会在下面几篇文章介绍。如上代码段中,创建了一个固定数量的线程池。
Executor executor = Executors.newFixedThreadPool(1);
((ExecutorService) executor).submit(futureTask);
3. 线程的安全
3.1 概念
当多个线程访问某个一类(对象或方法)时,这个类始终都能表现出正确的行为,那么这个类(对象或方法)就是线程安全的(即在多线程环境中被调用时,能够正确地处理多个线程之间的共享变量,使程序功能正确完成。
3.2 解决方法
可以通过加锁的方式:
- 同步(synchronized)代码块:只需要将操作共享数据的代码放在synchronized
- 同步(synchronized)方法:将操作共享数据的代码抽取出来放到一个synchronized方法里面就可以了
- Lock锁:加同步锁 lock() 以及释放同步锁unlock()
3.3.死锁和活锁
3.3.1死锁概念
死锁,是指两个或两个以上的进程(或线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。
活锁,任务或者执行者没有被阻塞,由于某些条件没有满足,导致一直重复尝试,失败,尝试,失败。
3.3.2死锁的条件
(1) 产生死锁的必要条件:
- 互斥条件:所谓互斥就是进程在某一时间内独占资源。
- 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
- 不剥夺条件:进程已获得资源,在末使用完之前,不能强行剥夺。
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
2) 死锁的解决方法:
- 撤消陷于死锁的全部进程。
- 逐个撤消陷于死锁的进程,直到死锁不存在。
- 从陷于死锁的进程中逐个强迫放弃所占用的资源,直至死锁消失。 从另外一些进程那里强行剥夺足够数量的资源分配给死锁进程,以解除死锁状态。
3.4乐观锁和悲观锁
1)悲观锁
悲观锁,总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁。
传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。Java 里面的同步原语 synchronized 关键字的实现也是悲观锁。
(2)乐观锁
乐观锁,顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制。乐观锁适用于多读的应用类型,这样可以提高吞吐量。常使用的为CAS方法。