一、相关概念:
进程:是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间
线程:
- 是进程中的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行,一个进程最少有一个线程
- 线程时间上是在进程的基础之上进一步划分,一个进程启动之后,里面的若干执行路径又可以划分成若干个线程
- 每个线程都拥有自己的栈空间,但是会共用一份堆内存
同步:排队执行,效率低但是安全
异步:同时执行,效率高但是数据不安全
并发:指两个或多个事件在同一个时间段内发生
并行:指两个或多个事件在同一时刻发生(同时发生)
线程的生命周期:
- NEW:尚未启动的线程
- Runnable:在Java虚拟机中执行的线程
- Blocked:被阻塞等待监视器锁定的线程
- Waiting:无期限等待另一个线程执行特定操作的线程
- Timed_Waiting:正在等待另一个线程执行最多指定等待时间的操作的线程
- Terminated:已经退出的线程
二、多线程技术:
两种开启多线程的方式:
- 继承Thread类的方式开启:
内部重写run方法,run方法就是线程要执行的任务方法,是一条新的执行路径,需要通过调用start方法触发 - 实现Runnable接口的方式开启:(较为常用)
实现接口的抽象方法run(),在主线程中,创建一个任务对象,再创建一个线程,将任务对象传入,调用线程的start方法触发
声明实现Runnable接口的优点:
- 通过创建任务,然后给线程分配的方式来实现的多线程,更适合多个线程同时执行相同任务的情况
- 可以避免单继承所带来的局限性
- 任务与线程本身是分离的,提高了程序的健壮性,减少程序间的耦合
- 后续学习的线程池技术,接收Runnable类型的任务,不接收Thread类型的线程
三、线程安全问题:
解决方案1:
隐式锁,同步代码块
格式:
synchronized(锁对象) {
要执行的代码;
}
解决方案2:
隐式锁,同步方法(可以被static修饰)
- 若不是静态,则锁对象为调用同步方法的对象
- 若为静态,则锁对象为==类名.Class==
Synchroized关键字特性:
- 原子性(互斥性):实现多线程的同步机制,使得锁内代码的运行必须先获得对应的锁,运行完后自动释放对应的锁
- 内存可见性:在同一锁的情况下,synchronized锁内的代码保证变量的可见性
- 可重入性:当一个线程获取一个对象的锁,再次请求改对象的锁时,是可以再次获取该对象的锁的
注意:如果在synchronized锁内发生异常,锁将会被释放
总结:
- synchronized会自动释放锁
- synchronized方法与synchronized(this)代码块,锁定的都是当前的对象,不同的只是同步代码的范围
- 静态synchronized方法与synchronized(class)代码块,锁定的都是Class锁,与对象锁不是同一个锁,两者同时使用可能会出现异步执行的效果
- 尽量不要使用synchronized(String),因为String的实际锁为String的常量池对象,多个值相同的String对象可能持有同一个锁
解决方案3:
显式锁 Lock 子类 ReentrantLock
private java.util.concurrent.locks.Lock lock = new ReentrantLock();
public void method() {
try {
lock.lock();
//获取到锁lock的同步块
} finally {
lock.unlock(); //释放锁lock
}
}
优点:
- 要求程序员手动释放锁,且一定要在finally代码块中释放
- 具有公平策略的选择,防止一个线程结束后立即重新获得运行权,在构造对象时,传入true参数:Lock lock = new ReentrantLock(true):
- 可以在获取锁的时候进行有条件的获取,可以设置等待时间,避免产生死锁问题:tryLock()和 tryLock(long timeout, TimeUnit unit)
- 可以获取锁的各种信息,可以用来监控锁的各种状态
- 可以利用Condition中的singal方法,实现对需要唤醒线程的精确控制
四、带返回值的线程:
//1. 编写实现类,实现Callable接口,并重写call方法:
class Mycallable implements Callable<T> {
@Override
public <T> call() throws Exception {
return T;
}
}
//2. 创建FutureTask对象,并传入第一部编写的Callable实现类对象
FutureTask<Integer> future = new FutureTask<>(new Mycallable());
//3. 通过Thread,启动线程
new Thread(future).start();
五、线程池:
意义:如果并发的线程数量很多,并且每个线程都仅仅执行一个很短时间的任务,那么此时频繁创建线程就会大大降低系统的效率。线程池就是一个可以容纳多个线程的容器,池中的线程可以反复使用,省去了频繁创建线程对象的操作,节省了大量的时间和资源
好处:
- 降低资源消耗
- 提高响应速度
- 提高线程的可管理性
分类:
-
缓存线程池:(长度无限制)
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在则创建线程,并放入线程池,然后使用
适用:执行很多短期异步的小程序或者负载较轻的服务器
public static void cacheThreadPool() {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 1; i <= 10; i++) {
final int ii = i;
try {
Thread.sleep(ii * 1);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(()->out.println("线程名称:" + Thread.currentThread().getName() + ",执行" + ii));
}
}
-
定长线程池:(长度是指定的数值)
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池,然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
适用:执行长期的任务,性能会好很多
public static void fixTheadPoolTest() {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int ii = i;
fixedThreadPool.execute(() -> {
out.println("线程名称:" + Thread.currentThread().getName() + ",执行" + ii);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
-
单线程线程池:
- 判断线程池的线程是否空闲
- 空闲则使用
- 不空闲,则等待池中的单个线程空闲后使用
适用:一个任务一个任务执行的场景
public static void singleTheadPoolTest() {
ExecutorService pool = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int ii = i;
pool.execute(() -> out.println(Thread.currentThread().getName() + "=>" + ii));
}
}
-
周期性任务定长线程池:
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程,并放入线程池,然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
周期性任务执行时:定时执行,当某个时机出发时,自动执行某任务
适用:周期性执行任务的场景
- 定时执行一次:
- 参数1:定时执行的任务
- 参数2:时长数字
- 参数3:时长数字的时间单位,TimeUnit的常量指定
- 周期执行的任务:
- 参数1:任务
- 参数2:延迟时长数字(第一次执行在什么时间后)
- 参数3:周期时长数字(每隔多久执行一次)
- 参数4:时长数字的单位
public static void sceduleThreadPool() {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
Runnable r1 = () -> out.println("线程名称:" + Thread.currentThread().getName() + ",执行:3秒后执行");
scheduledThreadPool.schedule(r1, 3, TimeUnit.SECONDS);
Runnable r2 = () -> out.println("线程名称:" + Thread.currentThread().getName() + ",执行:延迟2秒后每3秒执行一次");
scheduledThreadPool.scheduleAtFixedRate(r2, 2, 3, TimeUnit.SECONDS);
Runnable r3 = () -> out.println("线程名称:" + Thread.currentThread().getName() + ",执行:普通任务");
for (int i = 0; i < 5; i++) {
scheduledThreadPool.execute(r3);
}
}