文章目录
Java线程
简介
进程
在操作系统中独立运行的程序,一个运行的程序就对应着一个进程。在操作系统中可以同时运行多个程序。
线程
进程内部的一个执行单元,用来执行进程中的某个功能。在程序内部可以同时执行多个线程实现多个功能。
特性:
- 一个进程可以包含多个线程
- 进程是线程的容器
- 一个进程中的多个线程共享该进程的所有资源
创建线程
两种方式:
继承Thread类
实现Runnable接口
当前线程对象:Thread.currentThread()主线程:main,自定义线程:Thread-编号
继承Thread类
- 定义一个类继承自Thread类并重写run方法
- 建立一个线程实例
- 调用start方法启动线程,**不能直接调用run方法!!!**线程创建后并不一定立即执行,需要得到CPU时间片才会执行(具体可查阅操作系统相关资料)
实现Runnable接口
- 同样是定义一个类,实现Runnable接口的run方法
- 创建实现类的一个实例
- 创建线程实例,并传入实现类
- 调用start方法启动线程
两种实现方式的对比
继承自Thread类
- 线程执行的代码放在自定义的子类的重写run方法中
- 由于单重继承的规定,无法继承其他类
实现Runnable接口(推荐)
- 线程执行的代码放在接口实现类的run方法中
- 可以继承其他类
- 适合多个相同程序代码的线程去处理同一个资源
- 增强了程序的健壮性
线程的生命周期
相关方法:
方法 | 作用 | 说明 |
---|---|---|
start | 启动线程,让线程进入就绪态 | |
sleep | 休眠线程,线程由执行态进入阻塞态 | 静态方法 |
yield | 暂停执行线程,线程由执行态进入就绪态 | 静态方法 |
join | 暂停执行线程,让另一个线程执行完毕后再执行,当前进程进入阻塞态 | |
interrupt | 中断线程的休眠或等待状态 |
线程优先级
我们可以查看Thread类关于线程优先级的定义,优先级用int类型的数据表示,最小为1最大为10,默认优先级为5。线程的优先级可以调用getPriority()方法查看。设置优先级只能提高线程被优先执行的概率,并不是绝对意义上的优先。
public static final int MIN_PRIORITY = 1;
public static final int NORM_PRIORITY = 5;
public static final int MAX_PRIORITY = 10;
守护线程
public static void setDaemon(boolean on)方法在传入参数为真时将该线程标记为守护线程。
- 当正在运行的线程都是守护线程时,Java虚拟机退出
- 该方法必须在启动线程之前调用
- main线程是用户线程
守护线程典型使用场景
垃圾回收器就运行在守护线程中
线程安全问题
当多线程访问共享数据(临界资源)时,可能出现,由于CPU的切换,导致一个线程只执行了一部分,还没执行完就被换下CPU,此时另一个线程参与进来,导致数据发生异常的情况,这种问题就是线程安全问题。
解决方案:线程同步机制Synchronized + 锁
- 被Synchronized包围的代码块,称为同步代码块
- 被Synchronized包围的方法,称为同步方法(更常用)
- 普通方法,默认的是当前类锁
- 静态方法,默认的是当前类的Class对象锁
- 锁,也称为对象锁,每个对象都自带一个锁,且不同对象的锁是不一样的
执行过程
- 线程执行同步代码块或者同步方法时,必须获得特定对象的锁才行
- 一旦对象的锁被获取,那么该对象不再有锁,直到线程执行完同步代码块或同步方法时,才会释放对象的锁
- 如果线程无法获取特定对象上的锁,则会进入对象的锁池中进行等待,直到锁被归还给该对象,锁池中的线程会去竞争这个锁
- 只需要将关键的代码放进同步代码块或同步方法中,不然就和单线程没区别
接下来看一个实例:
创建一个Singleton类,每当创建该类的实例时,输出构造函数,并且定义了一个成员方法:getInstance如果变量instance是空指针则新建一个Singleton对象。
public class Singleton {
private static Singleton instance;
private Singleton(){
System.out.println("Singleton.Singleton()");
}
public static synchronized Singleton getInstance() throws InterruptedException {
if(instance == null) {
//Thread.sleep(100);
instance = new Singleton();
}
return instance;
}
}
正常情况下,两个进程执行getInstance方法,只会创建一个Singleton对象(如果不太能理解,请多看几遍代码),得到如下结果:
Singleton.Singleton()
securety.Singleton@6c197f00
securety.Singleton@6c197f00
但是,如果其中一个线程在执行语句if(instance == null)
后,instance = new Singleton()
前进行了线程切换,因为instance依然是null,所以另一个线程会新建一个Singleton对象,而原来的线程也会因为继续执行代码而新建第二个对象,得到如下结果:
Singleton.Singleton()
securety.Singleton@3f6d4362
Singleton.Singleton()
securety.Singleton@67413298
可以看到,确实新建了两个对象,如果将getInstance方法重新定义为同步方法,就能避免两个线程访问该方法的线程安全问题。
线程同步的优缺点
- 优点:解决了线程安全问题,使代码在某一时间只能被某一线程访问
- 缺点:由于需要进行锁的判断,消耗资源,效率变低
线程通信
锁池和等待池
每个对象都自带锁池和等待池
锁池:
- 当线程执行Synchronized块时无法获取特定对象上的锁,会进入该对象锁池
- 当锁被归还给对象时,锁池中的线程会竞争锁
- 获取对象锁的进程将执行对应同步方法,执行完毕后会释放锁
等待池:
- 当线程获取锁后,可以调用wait()方法放弃锁,进入对象等待池
当其他线程调用该对象的notify()或notifyAll()方法时,等待池中的线程会被唤醒,进入该对象的锁池
当线程获取对象的锁后,将从上次调用wait方法的位置开始继续执行
方法 | 作用 | 说明 |
---|---|---|
wait | 使线程放弃锁,线程进入等待池 | 可以调用等待超时时间,超时后线程会自动唤醒 |
notify | 随机唤醒等待池中的一个线程进入锁池 | 唤醒的是特定对象的等待池中的进程 |
notifyAll | 唤醒等待池中的所有线程 |
- 这三个方法都只能synchronize中使用,只有获取了锁的线程才能调用这些方法
- 等待和唤醒必须使用的同一对象
生产者-消费者问题
生产者-消费者问题是多线程同步的一个经典问题,即并发协作的问题,所谓生产者-消费者问题,实际上是包含了两种线程:生产者线程、消费者线程
生产者作用:
- 生产商品并放入缓冲区
- 缓冲区满时,生产者不可再生产商品
消费者线程:
- 从缓冲区中购买商品
- 当缓冲区为空时,消费者不可再购买商品
当缓冲区的商品变空时,消费者进入等待池,并在生产者生产商品后由生产者进程唤醒;同理当缓冲区的商品满时,生产者进入等待池,等待消费者将其唤醒。
根据分析,假设生产者2s生产一个商品,生产者类定义如下:
public class Producer extends Thread{
private String name;
private ProducePool pool;
public Producer(String name, ProducePool pool) {
this.name = name;
this.pool = pool;
}
@Override
public void run() {
while(true){
synchronized (pool){
if(pool.isFull()) {
try {
pool.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
else{
pool.put();
System.out.println("生产者" + this.name + "生产了一个商品,当前剩余商品数为: " + pool.getNum());
pool.notifyAll();
}
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
消费者类定义如下:
public class Consumer extends Thread{
private String name;
private ProducePool pool;
public Consumer(String name, ProducePool pool) {
this.name = name;
this.pool = pool;
}
@Override
public void run() {
while(true){
synchronized (pool){
if(pool.isEmpty()) {
try {
pool.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
else{
pool.get();
System.out.println("消费者" + this.name + "消费了一个商品,当前剩余商品数为: " + pool.getNum());
pool.notifyAll();
}
}
}
}
}
缓冲区定义如下:
public class ProducePool {
private int num;
private static final int MAX_COUNT = 20;
public void put(){
num++;
}
public void get(){
num--;
}
public int getNum(){
return num;
}
public boolean isEmpty(){
return this.num == 0;
}
public boolean isFull(){
return this.num == MAX_COUNT;
}
}
接着新建三个生产者线程和一个消费者线程,可以看到控制台窗口的动态输出:
线程单例
为每个线程提供一个实例
- 同一个线程获取的同一个实例
- 不同的线程获取的是不同的实例
Java中提供了一个ThreadLocal,直接提供了线程单例的解决方案
- 用于管理变量,提供了线程局部变量
- 他为变量在每个线程中都存储了一个本地的副本