JUC 多线程详解（狂神说笔记一）

最新推荐文章于 2024-08-12 14:47:42 发布

孙小圣98

最新推荐文章于 2024-08-12 14:47:42 发布

阅读量552

点赞数

分类专栏：多线程文章标签： java

本文链接：https://blog.csdn.net/weixin_45457662/article/details/111530982

版权

多线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

多线程详解（狂神说笔记）

创建线程的三种方式

创建方式一：继承thread方法，重写run()方法，调用start开启线程
- 注意：线程开启不一定立即执行，由cpu调度
- **不建议使用：避免OOP单继承局限性 **
创建方式二：实现runnable接口,重写run方法，执行线程需要丢入runnable接口实现类.|调用start()方法（推荐使用）
- 推荐使用:避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

在这里插入图片描述

创建方式三：实现Callable接口（了解）
- 1．实现Callable接口，需要返回值类型
- 2．重写call方法，需要抛出异常
- 3．创建目标对象
- 4．创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
- 5．提交执行: Future result1 = ser.submit(t1);
- 6．获取结果: boolean r1 = result1.get()
- 7．关闭服务: ser.shutdownNow();

静态代理

线程状态

new Thread t = new Thread()线程对象一旦创建就进入到了新生状态
就绪当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行
运行状态 进入运行状态，线程才真正执行线程体的代码块
阻塞状态 当调用sleep, wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行。
dead 线程中断或者结束，一旦进入死亡状态，就不能再次启动

线程方法

在这里插入图片描述

停止线程

在这里插入图片描述

线程休眠 sleep()

sleep(毫秒数)指定当前线程停止的实践
sleep()存在异常interruptedException
sleep()实践到达后线程进入就绪状态
sleep()可以模拟网络延时,倒计时等
每一个对象都有一个锁,sleep不会释放锁

线程礼让 yield()

礼让线程,让当前正在执行的线程暂停,但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度,礼让不一定成功,看CPU心情

线程强制执行 join()

Join合并线程,待此线程执行完成后,在执行其他线程,其他线程阻塞
可以想象成插队

线程优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程;线程调度器按照优先级决定该调度哪个线程来执行
线程的优先级用数字来表示,范围从1~10
- Thread.MIN_PRIORITY = 1
- Thread.MAX_PRIORITY= 10
- Thread.NORM_PRIORITY = 5
使用getPriority()和setPriority()来获取或改变优先级

守护线程setDeamon()

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
如后台记录操作日志,监控内存,垃圾回收

线程同步

处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我们就需要线程同步,线程同步其实是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕,下一个线程在使用
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问的冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入

锁机制synchronized,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可,存在一下问题
- 一个线程持有锁会导致其他所有需要此锁的进程挂起
- 在多线程竞争的情况下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题

同步方法和同步块

同步块: synchronized(obj){}
obj称之为同步监视器
- obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器,因为同步方法中的同步监视器就是this,就是这个对象本身,或者是class
同步监视器的执行过程
- 第一个线程访问,锁定同步监视器,执行其中的代码
- 第二个线程访问,发现同步监视器被锁定,无法访问
- 第一个线程访问完毕,解锁同步监视器
- 第二个线程访问,发现同步监视器没有锁,然后锁定并访问
同步方法在方法上添加synchronized关键子,锁的是对象本身

死锁

多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源释放才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形,某一个同步块同时拥有"两个以上的对象锁"时,就可能发生死锁现象

死锁产生的条件

互斥条件: 一个资源每次只能被一个进程使用
请求保持条件: 一个进程因请求资源而阻塞时.对以获得的资源保持不放
不剥夺条件: 进程已获得的资源,在未使用完之前,不能强行剥夺
循环等待条件: 若干进程之间形成一种头尾相接的循环等待资源关系

Lock锁

从JDK1.5开始,java提供了更为强大的线程同步机制——通过显示定义同步锁对象来实现同步,同步锁使用lock对象来充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中.比较常用的是ReentrantLock,可以显示加锁,释放锁

实战

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}


class TestLock2 implements Runnable {

    int ticketNums = 10;
    //定义Lock锁
    private ReentrantLock reentrantLock = new ReentrantLock();


    @Override
    public void run() {

        while (true) {
            try {
                reentrantLock.lock(); //加锁
                if(ticketNums > 0 ){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "购买了第" + ticketNums-- + "张票");

                } else {
                    break;
                }
            } finally {
                //解锁
                reentrantLock.unlock();
            }

        }
    }
}

和synchronized对比

Lock是显示锁(手动开启和关闭,别忘记关闭锁) synchronized是隐式锁,出了作用域自动释放
Lock只有代码块锁,synchronized有代码块锁和方法锁
使用lock锁,JVM将花费较少的时间来调度线程,性能更好,并且具有更好的扩展性(提供更多的子类)
优先使用顺序
- Lock > 同步代码块 > 同步方法

线程协作

生产者和消费者问题
- 假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库产品取走消费
- 如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止
- 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止
这是一个线程同步问题,生产者和消费者共享一个资源,并且生产者和消费者之间相互依赖,互为条件
- 对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,又要马上通知消费者消费
- 对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费
- 在生产者消费者问题上,仅有synchronized是不够的
  - synchronized可阻止并发更新同一个共享资源,实现了同步
  - synchronized不能用来实现不同线程之间消息传递(通信)

在这里插入图片描述

解决方式

并发协作模式"生产者/消费者模式" ===>管程法

生产者: 负责生产数据的模块(可能是方法,对象,线程,数组)
消费者: 负责处理数据的模块(可能是方法,对象,线程,数组)
缓冲区: 消费者不能直接使用生产者的数据,他们之间有个缓冲区

生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

//测试生产者消费者模型 --->管程法

//产品
public class Product {
    private int id;

    public Product(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

//消费者
public class ConsumerThread extends Thread {

    private SyncContainer syncContainer;

    public ConsumerThread(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Product pop = syncContainer.pop();
            System.out.println("消费了第"+ pop.getId() + "号产品");
        }
    }
}


//生产者
public class ProviderThread extends Thread {

    //创建好的缓冲区
    private SyncContainer syncContainer;

    public ProviderThread(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了" + i + "只鸡!");
            syncContainer.push(new Product(i));
        }
    }
}


//容器
public class SyncContainer {

    //容器大小
    Product[] products = new Product[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Product product){
        //如果容器满了,就要等待消费者
        //通知消费者消费,生产者等待
        if(count == products.length) {
            try {
                this.wait();
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        //如果容器没有满,就要生产产品
        products[count] = product;
        count++;
        //可以通知消费者消费
        this.notifyAll();
    }


    //消费者消费产品
    public synchronized Product pop(){
        //判断容器是否为空
        if(count == 0){
            //通知生产者生产.消费者等待
            try {
                this.wait();
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }

        //如果可以消费
        count--;
        Product product =  products[count];

        //通知生产者生产
        this.notifyAll();
        return product;
    }
}


public class Main {

    public static void main(String[] args) {
        SyncContainer container = new SyncContainer();
        new ProviderThread(container).start();
        new ConsumerThread(container).start();
    }
}

并发协作模式"生产者/消费者模式" ===>信号灯法

//产品-->节目
public class TV {

   //演员表演,观众等待
   //观众观看,演员等待
   String voice;   //表演的节目
   boolean flag = true;

   //表演
   public synchronized void play(String voice) {

       if(!flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

       System.out.println("演员表演了" + voice);
       //通知观众观看
       this.voice = voice;
       this.notifyAll();
       this.flag = !flag;

   }

   //观看
   public synchronized void watch(){
       if(flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("观众观看了" + voice);
       //通知演员表演
       this.notifyAll();
       this.flag = !flag;
   }
}

public class Player extends Thread {
   private TV tv = null;

   public Player(TV tv) {
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           tv.play("表演了" + i + "号节目");
       }
   }
}

public class Watcher extends Thread {

   private TV tv = null;

   public Watcher(TV tv) {
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           tv.watch();
       }
   }
}

//测试生产者消费者问题:信号灯法,标志位解决
public class Main {

   public static void main(String[] args) {
       TV tv = new TV();
       new Watcher(tv).start();
       new Player(tv).start();

   }
}

使用线程池

背景: 经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大
思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完毕放回池中,可以避免频繁的创建销毁,实现重复利用,类似生活中的工共交通工具
好处
- 提高了响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理(…)
  - corePoolSize: 核心池的大小
  - maximumPoolSize: 最大线程数
  - keepAliveTime: 线程没有任务时最多保持多长时间后会终止

blic class Main {

public static void main(String[] args) {
    TV tv = new TV();
    new Watcher(tv).start();
    new Player(tv).start();

}

}

使用线程池

背景: 经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大
思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完毕放回池中,可以避免频繁的创建销毁,实现重复利用,类似生活中的工共交通工具
好处
- 提高了响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理(…)
  - corePoolSize: 核心池的大小
  - maximumPoolSize: 最大线程数
  - keepAliveTime: 线程没有任务时最多保持多长时间后会终止