线程安全
一、概述
1.资源复用
2.死锁
(1)概念:
多个线程各自占有一些共享资源,并且互相等待其它线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。某一个同步块同时拥有 “两个以上对象的锁” 时,就可能会发生 “死锁” 的问题。
小提示:想保证资源唯一,定义成 Static 即可。
(2)产生死锁的四个必要条件:
- 互斥条件 : 一个资源每次只能被一个进程使用。
- 请求与保持条件 : 一个进程因请求资源而阻塞时,对已获得的资源保持不放。
- 不剥夺条件 : 进程已获得的资源,在末使用完之前,不能强行剥夺。
- 循环等待条件 : 若干进程之间形成一种头尾相接的循环等待资源关系。
上面列出了死锁的四个必要条件,我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生。
二、出现线程安全的例子
public class RunnableImpl implements Runnable{
//定义一个多线程共享的票源
private int ticket = 100;
//设置线程任务;卖票
@Override
public void run() {
//使用死循环,让卖票操作重复执行
while (true) {
if (ticket>0){
//提高安全问题出现的概率,让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票");
ticket--;
}
}
}
}
public static void main(String[] args) {
RunnableImpl runnable = new RunnableImpl();
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
Thread thread3 = new Thread(runnable);
thread1.start();
thread2.start();
thread3.start();//会出现线程安全问题
}
分析:
三、线程同步
当我们使用多个线程访问同一资源的时候,且多个线程中对资源有写的操作,就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题,Java中提供了同步机制(synchronized)来解决。
根据案例简述︰
窗口1线程进入操作的时候,窗口2和窗口3线程只能在外等着,窗口1操作结束,窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候,其他线程不能修改该资源,等待修改完毕同步之后,才能去抢夺CPU资源,完成对应的操作,保证了数据的同步性,解决了线程不安全的现象。
为了保证每个线程都能正常执行原子操作Java引入了线程同步机制。那么怎么去使用呢?
有三种方式完成同步操作︰
1.同步代码块。
2.同步方法。
3.锁机制。
1、同步代码块
- 同步代码块: synchronized关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。
格式 :
synchronized(同步锁){
需要同步操作的代码
}
注意:
1.通过代码块中的锁对象,可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用: 把同步代码块锁住,只让一个线程在同步代码块中执行
同步锁 :
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
- 锁对象可以是任意类型。
- 多个线程对象要使用同一把锁.
- 注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
使用同步代码块解决代码(示例)∶
//同步代码块
synchronized (m_object){
if (ticket>0){
//提高安全问题出现的概率,让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票");
ticket--;
}
}
同步技术的原理:
2.同步方法
同步方法 : 使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
//格式
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步锁是谁?
对于非 static 方法,同步锁就是 this。
对于 static方法, 我们使用当前方法所在类的字节码对象(类名.class)。
3、Lock锁
java.util.concurrent.locks.Lock’机制提供了比 synchronized 代码块和 synchronized 方法更几泛的锁定操作,同步代码块/同步方法具有的功能 Lock 都有,除此之外更强大,更体现面向对象。
使用步骤:
1.在成员位置创建一个ReentrantLock 类 对象
2.在可能会出现安全问题的代码前调用Lock接口中的Lock( )方法 获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的unLock( )方法 释放锁
Lock锁也称同步锁,加锁与释放锁方法化了,如下:
public void lock() //加同步锁。
public void unlock()//释放同步锁。
4、synchronized 与 Lock 的对比
- Lock是显式锁(手动开启和关闭锁,别忘记关闭锁), synchronized是隐式锁,出了作用域自动释放。
- Lock只有代码块锁,synchronized有代码块锁和方法锁。
- 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序
- Lock > 同步代码块(已经进入了方法体,分配了相应资源) > 同步方法(在方法体之外)
四、线程间通信
一、概念
- 多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。
- 比如∶线程A用来生成包子的,线程B用来吃包子的,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生产,一个是消费,那么线程A与线程B之间就存在线程通信问题。
- 为什么要处理线程间通信?
- 多个线程并发执行时,在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信,以此来帮我们达到多线程共同操作一份数据。
- 如何保证线程间通信有效利用资源?
- 多个线程在处理同一个资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变星的使用或操作。就是多个线程在操作同一份数据时,避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—―等待唤醒机制。
二、线程状态概述
当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。在线程的生命周期中,有几种状态呢?在API中 java.lang.Thread.State这个枚举中给出了六种线程状态∶
我们不需要去研究这几种状态的实现原理,我们只需知道在做线程操作中存在这样的状态。那我们怎么去理解这几个状态呢,新建与被终止还是很容易理解的,我们就研究一下线程从Runnable(可运行)状态与非运行状态之间的转换问题。
1、计时等待
2、锁阻塞
3、实现计时等待的方式
一、使用 synchronized 关键字 + Object类的方法
进入到Timewaiting(计时等待)有两种方式 :
- 使用sleep(Long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态
- 使用wait(Long p)方法, wait方法如果在毫秒值结束之后,还没有被not ify唤醒,就会自动醒来,线程睡醒进入到Runnable/BLocked状态。
唤醒的方法 :
- void notify() 唤醒在此对象监视器上等待的单个线程。
- void notifyALL() 唤醒在此对象监视器上等待的所有线程。
生产者消费者模型 常用解决方法 :
- 利用缓冲区–即消息队列 解决(管程法)
- 利用标志位解决 (信号灯法)
例子:
/**
* @ClassName:PCtest
* @创建者: LLY
* @创建时间: 2021/5/9 22:00
* @version: 1.0
* @描述: 生产者消费者模型 ->利用缓冲区解决(管程法)
* 只有锁对象才能调用wait和notify方法
* Object类中的方法
* void wait() 在其他线程调用此对象的notify()方法或notifyAll()方法前,导致当前线程等待。
* void notify() 唤醒在此对象监视器上等待的单个线程。会继续执行wait方法之后的代码
*/
// 生产者、消费者、产品、仓库(缓冲区)
public class PCtest {
public static void main(String[] args) {
Warehouse warehouse = new Warehouse();
new Producter(warehouse).start();
new Consumer(warehouse,"顾客1").start();
}
}
//生产者
class Producter extends Thread{
Warehouse warehouse = new Warehouse();
public Producter(Warehouse warehouse) {
this.warehouse = warehouse;
}
@Override
public void run() {
//总共做100件产品
for (int i = 1; i <= 100; i++) {
Product product = new Product(i, "烤鸭");
try {
warehouse.push(product);
System.out.println("生产者烤好了第"+i+"只烤鸭!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//消费者
class Consumer extends Thread{
Warehouse warehouse = new Warehouse();
public Consumer(Warehouse warehouse,String name) {
super(name);
this.warehouse = warehouse;
}
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
try {
Product product = warehouse.pop();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"吃了第"+i+"只烤鸭!");
}
}
}
//产品
class Product{
Integer ID;//产品编号
String Pname;//产品名称
public Product(Integer ID, String pname) {
this.ID = ID;
Pname = pname;
}
}
//仓库(缓冲区)
class Warehouse{
Product[] products = new Product[10];
Integer count = 0;
//放入仓库
public synchronized void push(Product p) throws InterruptedException {
//如果仓库满了,就通知消费者线程消费,自身等待。
if (count == products.length-1){
this.wait();
}
products[count] = p;
count++;
this.notifyAll();
}
//拿出仓库
public synchronized Product pop() throws InterruptedException {
if (count == 0) {
this.wait();
}
count--;
Product product = products[count];
this.notifyAll();
return product;
}
}
/**
* @ClassName:PCtest2
* @创建者: LLY
* @创建时间: 2021/5/10 11:02
* @version: 1.0
* @描述:生产者消费者模型 -> 标志位解决 (信号灯法)
*/
public class PCtest2 {
public static void main(String[] args) {
TV tv = new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
//生产者
class Player extends Thread{
TV m_tv;
public Player(TV tv) {
m_tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
if ( i % 5 > 2)
m_tv.show("相声");
else
m_tv.show("广告");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//消费者
class Watcher extends Thread{
TV m_tv;
public Watcher(TV tv) {
m_tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
m_tv.watch();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//产品
class TV{
boolean flag = true; // T 没有节目, F 有节目
String mv;//节目名称
public synchronized void show(String mv) throws InterruptedException {
//有节目,通知观众看
if (!flag){
this.wait();
}
//演员录节目,观众等待
System.out.println("录制好了!"+mv);
this.mv = mv;
this.notifyAll();
this.flag = !this.flag;
}
//节目录好,观众观看,演员休息
public synchronized void watch() throws InterruptedException {
if (flag){
this.wait();
}
System.out.println("观看完了!"+this.mv);
this.notifyAll();
this.flag = !this.flag;
}
}
二、使用 Lock 锁 + condition
Condition是在 java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition,阻塞队列实际上是使用了Condition来模拟线程间协作。
Condition是个接口,基本的方法就是await()和signal()方法;
Condition依赖于Lock接口,生成一个Condition的基本代码是lock.newCondition()。
调用Condition的await()和signal()方法,都必须在lock保护之内,就是说必须在lock.lock()和lock.unlock之间才可以使用。
- Conditon中的await()对应Object的wait();
- Condition中的signal()对应Object的notify();
- Condition中的signalAll()对应Object的notifyAll()。
例子
public class ConTest {
final Lock lock = new ReentrantLock();
final Condition condition = lock.newCondition();
public static void main(String[] args) {
ConTest test = new ConTest();
Producer producer = test.new Producer();
Consumer consumer = test.new Consumer();
consumer.start();
producer.start();
}
class Consumer extends Thread{
@Override
public void run() {
consume();
}
private void consume() {
try {
lock.lock();
System.out.println("我在等一个新信号"+this.currentThread().getName());
condition.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally{
System.out.println("拿到一个信号"+this.currentThread().getName());
lock.unlock();
}
}
}
class Producer extends Thread{
@Override
public void run() {
produce();
}
private void produce() {
try {
lock.lock();
System.out.println("我拿到锁"+this.currentThread().getName());
condition.signalAll();
System.out.println("我发出了一个信号:"+this.currentThread().getName());
} finally{
lock.unlock();
}
}
}
}
注意:
哪怕只通知了一个等待的线程,被通知线程也不能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以她需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用wait方法之后的地方恢复执行。
总结如下 :
- 如果能获取锁,线程就从WAITING状态变成 RUNNABLE状态
- 否则,从wait set出来,又进入entry set,线程就从WAITING 状态又变成BLOCKED状态
调用wait和notify方法需要注意的细节
- wait方法与notify方法必须要由同一个锁对象调用。因为∶对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
- wait方法与notify方法是属于Object类的方法的。因为︰锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
- wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为∶必须要通过锁对象调用这2个方法。
五、线程池(简述)
详细 叙述 参照 JAVA进阶之JUC并发编程
一、概述
线程池∶其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。
由于线程池中有很多操作都是与优化资源相关的,我们在这里就不多赘述。
我们通过一张图来了解线程池的工作原理 :
合理利用线程池能够带来三个好处︰
- 降低资源消耗。减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
- 提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机
二、使用
ExecutorService : 真正的线程池接口。常见子类 ThreadPoolExecutor【推荐使用】。
使用在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂,生成一些常用的线程。
Executors : 线程池工具类
、线程池的工厂类,用于创建并返回不同类型的线程池
创建线程池的方法如下∶
public static ExecutorService newFixedThreadPool(int nThreads) : 返回线程池对象。
(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
使用线程池对象的方法如下:
- void execute(Runnable command) : 执行任务/命令,没有返回值,一般用来执行 Runnable
- Futuresubmit(Callable task) : 执行任务,有返回值,一般用来执行 Callable
- void shutdown() : 关闭线程池
使用步骤 :
- 创建线程池对象。
- 创建Runnable接口子类对象。
- 提交Runnable接口子类对象。(take task)
- 关闭线程池(一般不做)。
例子:
public class RunnableImpl implements Runnable{
@Override
public void run() {
System.out.println("线程名称为:"+Thread.currentThread().getName()+"产生了一个新线程!");
}
}
public static void main(String[] args) {
//1、使用线程池的工厂类 Executors 提供的静态方法newFixedThreadPool()生产一个指定线程数量的线程池
ExecutorService ex = Executors.newFixedThreadPool(2);
//3、调用Executors中的方法submit(),传递线程任务(实现类),开启线程,执行线程任务。
ex.submit(new RunnableImpl());
ex.submit(new RunnableImpl());
ex.submit(new RunnableImpl());
}