多线程详解

线程简介

操作系统中运行的程序就是进程，比如你的QQ、播放器、游戏、IDE

一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等，线程是CPU调度和执行的单位。

线程实现

线程的创建

1. 继承Thread类（重点）
2. 实现Runnable接口（重点）
3. 实现Callable接口（了解）

继承Thread类

• 自定义线程类继承Thread类
• 重写run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

两个线程交替执行，多线程实现了

package day03;

public class Demo11 extends Thread {
    @Override
    public void run() {
        for(int i = 0; i < 20; i++){
            System.out.println("重写run()方法！！！");
        }

    }

    public static void main(String[] args) {
        Demo11 demo11 = new Demo11();
        demo11.start();

        for(int i = 0; i < 20; i++){
            System.out.println("主线程！！！");
        }
    }
}

实现Runnable接口

• 自定义线程类实现Runnable接口
• 重写run()方法
• 创建线程对象，调用start()方法启动线程

推介使用Runnable对象，因为Java单继承的局限性

package day03;

public class Demo12 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 20; i++){
            System.out.println("重写run()方法！！！");
        }
    }

    public static void main(String[] args) {
        // 静态代理实现
        Demo12 demo12 = new Demo12();
        Thread thread = new Thread(demo12);
        thread.start();

        for(int i = 0; i < 20; i++){
            System.out.println("主线程！！！");
        }
    }
}

实现Callable接口

• 实现Callable接口，需要返回值类型
• 重写call方法，需要抛出异常
• 创建目标对象
• 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(3);
• 提交执行：Future r1 = ser.submit(a);
• 获取结果：Object r11 = r1.get();
• 关系服务：ser.shutdown();

可以定义返回值；可以抛出异常

package day03;

import day02.Demo01;

import java.util.concurrent.*;

public class Demo14 implements Callable {
    @Override
    public Object call() throws Exception {
        return "进程";
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        创建目标对象
        Demo14 a = new Demo14();
        Demo14 b = new Demo14();
        Demo14 c = new Demo14();

//        创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

//        提交执行
        Future r1 = ser.submit(a);
        Future r2 = ser.submit(b);
        Future r3 = ser.submit(c);

//        获得结果
        Object r11 = r1.get();
        Object r22 = r2.get();
        Object r33 = r3.get();

//        关闭服务
        ser.shutdown();

    }
}

并发问题

• 多个线程同时操作同一个对象
• 产生问题：线程不安全，数据紊乱
• 解决方法：

package day03;

public class Demo13 implements Runnable{
    private int num = 10;

    @Override
    public void run() {
        while (true){
            if(num <= 0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到第"+num+"票");
            num--;
        }
    }

    public static void main(String[] args) {
        Demo13 demo13 = new Demo13();

        new Thread(demo13,"小明").start();

        new Thread(demo13,"老师").start();

        new Thread(demo13,"黄牛").start();
    }
}

静态代理模式

• 真实对象和代理对象都要实现同一个接口
• 代理对象要代理真实角色
• 优点：代理对象可以做很多真实对象完成不了的事情；真实对象专注完成自己的任务；类似于多线程原理

package day03;

public class StaticProxy {

    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());

        weddingCompany.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

//真实角色
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("我要结婚了。。。。");
    }
}

//代理角色
class WeddingCompany implements Marry{

    private Marry marry;

    public WeddingCompany(Marry marry){
//        代理谁--->真实目标角色
        this.marry = marry;
    }

    @Override
    public void HappyMarry() {
        before();
        
//        真实对象结婚
        this.marry.HappyMarry();
        after();
    }

    public void before(){
        System.out.println("结婚之前，布置现场");
    }

    public void after(){
        System.out.println("结婚之后，收钱");
    }
}

Lamda表达式

• 避免匿名内部类定义过多

• 其实属于函数式编程的概念

  • (params) -> expression[表达式]
  • (params) -> statement[语句]
  • (params) -> {statements}

• 函数式接口

  • 任何接口，如果只包含一个个抽象方法，那么就是一个函数式接口

    package day03;
    
    public interface Demo06 {
      void getID();
    }
    

• 对于函数式接口，我们可以通过Lamda表达式来创建该接口的对象

package day03;

public class Demo15 {

//3。静态内部类
    static class Like2 implements ILike{
    @Override
    public void lambda() {
        System.out.println("lambda2");
    }
}


    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

//     4局部内部类
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("lambda3");
            }
        }

        like = new Like3();
        like.lambda();

//      5匿名内部类
        like = new ILike(){
            @Override
            public void lambda() {
                System.out.println("lambda4");
            }
        };

        like.lambda();

//      6使用lambda简化
        like = () ->{
            System.out.println("lambda5");
        };
        like.lambda();
    }

}

//1。定义一个函数式接口
interface ILike{
    void lambda();
}

//2。实现类
class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("lambda");
    }
}

package day04;

import java.util.function.IntConsumer;

public class Demo01 {
    public static void main(String[] args) {
//        lambda表达式
        Demo02 lambda = (int a) -> {
            System.out.println("lambda"+a);
        };

        lambda.run(4);

//        简化：去掉参数类型
        lambda = (a) -> {
            System.out.println("lambda"+a);
        };
        lambda.run(5);

//        简化：去掉括号（方法体中多行内容实用）
        lambda = a -> {
            System.out.println("lambda"+a);
        };

        lambda.run(6);

//        简化：去掉花括号(多行不能使用)
        lambda = (a) -> System.out.println("lambda"+a);

        lambda.run(7);


    }
}

interface Demo02{
    void run(int a);
}

Lambda表达式总结

• 前提是接口为函数式接口
• 多个参数也可以去掉参数类型、要去掉就都去掉，必须加上括号
• 如果表达式只能有一行的情况下可以简化成一行，如果有多行，那么就用代码块包裹

线程状态

• new----->就绪状态>------->运行状态-------->dead； 运行状态------>阻塞状态----->就绪状态
• 更改线程的优先级：setPrioriry(int newPoriority)
• 在执行的毫秒数内让当前正在执行的线程休眠：static void sleep(long millis)
• 等待该线程终止：void join()
• 暂停当前正在执行的线程对象，并执行其他线程：static void yield()
• 中断线程，不推荐使用：void interrupt()
• 测试线程是否处于活跃状态：boolean isAlive()

线程停止(推荐使用方法)

package day04;

public class Demo03 implements Runnable{
//    1.设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run......Thread"+i++);
        }
    }

//    设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();

//    启动多线程
        new Thread(demo03).start();

        for (int i = 0; i <100;i++){
            if (i == 90){
//                调用stop方法切换标志位，让线程停止
                demo03.stop();
                System.out.println("线程停止了");
            }
            System.out.println("main主线程");
        }
    }
}

线程休眠

• 每一个对象都有一个锁，sleep不会释放锁

package day04;

//模拟网络延迟：放大问题第发生性
public class Demo04 implements Runnable {

//    票数
    private int ticketNums = 10;


    @Override
    public void run() {
        while (true){
            if(ticketNums <= 0){
                break;
            }

//            模拟网络延迟
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();

        new Thread(demo04,"小明").start();
        new Thread(demo04,"老师").start();
        new Thread(demo04,"黄牛党").start();
    }
}

package day04;

import java.sql.SQLOutput;
import java.text.SimpleDateFormat;
import java.util.Date;

//模拟倒计时
public class Demo05 {
    public static void main(String[] args) {
//        打印当前系统时间
        Date date = new Date(System.currentTimeMillis());

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));

//                更新当前时间
                date = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void testDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0){
                break;
            }
        }
    }
}

线程礼让

• 让线程转换为就绪状态
• 礼让线程，让当前的正在执行的线程暂停，但不堵塞
• 让CPU重新调度，礼让不一定成功，看CPU心情

package day04;

//测试礼让线程
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"A线程").start();

        new Thread(myYield,"B").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");

//        线程礼让
        Thread.yield();

        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

线程强制执行

• join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
• 可以想象成插队

package day04;

public class TestJoin implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++){
            System.out.println("线程VIP来了"+i);
        }
    }


    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();

        Thread thread = new Thread(testJoin);
        thread.start();


        for (int i = 0; i < 200; i++){
            if(i == 50){
                thread.join();
            }
            System.out.println("main线程"+i);
        }
    }
}

观测线程状态

package day04;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

//观测线程的状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("========");
        });

//        观察线程状态
        Thread.State state = thread.getState();
        System.out.println(state);

//      观察启动后
        thread.start();
        System.out.println(thread.getState());

//        只要线程不终止，就一直输出状态
        while (state !=Thread.State.TERMINATED){
            Thread.sleep(100);
//        更新线程状态
            state = thread.getState();
            System.out.println(state);
        }
    }
}

线程的优先级

• 线程的优先级用数字表示，范围从0～10
• Thread.MIN_PRIORITY = 1
• Thread.MAX_PRIORITY = 10
• Thread.NORM_PRIORITY = 5
• 使用以下方式改变或者获取优先级
  • getPriority()
  • setPriority(int xxx)
• 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用，这都是看CPU的调度

package day04;

public class TestPriority {
    public static void main(String[] args) {
//        主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

//        先设置优先级，再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

        t5.setPriority(8);
        t5.start();

        t6.setPriority(9);
        t6.start();


    }
}


class MyPriority  implements Runnable{
    @Override
    public void run() {
            System.out.println(Thread.currentThread().getState()+"====="+Thread.currentThread().getPriority());
    }
}

守护线程

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

package day04;

public class Demo06 {
    public static void main(String[] args) {
        God god = new God();

        You you = new You();

        Thread thread = new Thread(god);
//        默认是false表示用户线程，正常的线程都是用户线程
        thread.setDaemon(true);

//        守护线程
        thread.start();

//        用户线程
        new Thread(you).start();
    }

}

class God  implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("永生！！！");
        }
    }
}

class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i < 36500;i++){
            System.out.println("你开心！！！");
        }
        System.out.println("goodBye！world");
    }
}

线程同步

• 多个线程操作同一个资源：并发

• 其实是一个种等待机制

• 锁和队列：为线程同步形成条件

1. 由于同一个进程的多个线程共享同一块存储空间，带来方便的同时，也带来了访问冲突问题，为了保证数据再方法中被访问时的正确性，在访问的时候加锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可

   存在以下问题

   • 一个线程持有锁会导致其他所有需要此锁的线程挂起
   • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延迟，引起性能问题
   • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

2. synchronized:默认锁住this

3. synchronized代码块：可以锁住任何对象

4. 锁住的对象就是变化的量

• 同步块：synchronized(obj){}
• obj称之为同步监视器
  • obj可以是任何对象，但是推荐使用共享资源作为同步监视器
  • 同步方法中无需执行同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class【反射中讲解】

package day04;

//不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"小明").start();

        new Thread(buyTicket,"小红").start();

        new Thread(buyTicket,"黄牛党").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNums = 100;

    boolean flag = true; //外部停止


    @Override
    public void run() {
//        买票
        while (flag){
            buy();
        }
    }

    private synchronized void buy(){
        if (ticketNums <= 0){
            flag = false;
            return;
        }else {
            System.out.println(Thread.currentThread().getName()+"拿到第"+ticketNums--+"票");
        }
    }
}

package day04;

//不安全取钱
public class UnsafeBank {
    public static void main(String[] args) {

//        账户
        Account account = new Account(100, "结婚基金");

//
        Drawing you = new Drawing(account, 50, "你");

        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();

        girlFriend.start();
    }
}

//账户
class Account{
    int money;
    String name;

    public Account(int money,String name){
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
//    账户
    Account account;

//    取了多少钱
    int drawingMoney;

//    现在手机多少钱
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

//    取钱
    @Override
    public void run(){
        
//        锁的对象就是变化的量，需要增删改的对象
        synchronized (account){
            if (account.money - drawingMoney < 0){
                System.out.println(Thread.currentThread().getName()+"钱不够");
                return;
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

//        卡内余额
            account.money = account.money-drawingMoney;

//        你手里多钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name+"余额为"+account.money);
            System.out.println(this.getName()+"手里为"+nowMoney);
        }
    }
}

package day04;

import java.util.ArrayList;

//线程不安全多集合
public class UnsafeList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i <=10000; i++){
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());

    }
}

死锁

• 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”问题。
• 死锁产生条件：我们只要破解其中的任意一个或者多个条件就可以避免死锁的残生
  • 互斥条件：一个资源每次只能被一个进程使用
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  • 不剥夺：进程已获得的资源，在未使用完之前，不能强行剥夺
  • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

Lock

• 锁提供了对共享资源的独占访问，每一次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象

  package day04;
  
  import java.util.concurrent.locks.ReentrantLock;
  
  //测试lock锁
  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;
  
      private final ReentrantLock lock = new ReentrantLock();
  
      @Override
      public void run() {
          while (true){
              try {
  //                加锁
                  lock.lock();
                  if (ticketNums > 0){
                      try {
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      System.out.println(ticketNums--);
                  }else {
                      break;
                  }
              }finally {
  //                减锁
                  lock.unlock();
              }
          }
      }
  }
  

synchronized与Lock的对比

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

线程通信问题

线程协作

管理法

package day04;
//测试：生产者消费者模型，利用缓冲区解决：管理法
//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();

        new Predictor(synContainer).start();

        new Consumer(synContainer).start();
    }
}

//生产者
class Predictor extends Thread{
    SynContainer container;

    public Predictor(SynContainer container){
        this.container = container;
    }

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

//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"只鸡");
        }
    }
}

//产品
class Chicken{
//    产品id
    int id;

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


//缓存区
class SynContainer{
//    需要一个容器大小
    Chicken[] chickens = new Chicken[10];

//    容器计数器
    int count = 0;

//    生产者放入产品
    public synchronized void push(Chicken chicken){
//      如果容器满了，就需要等待消费者消费
        if (count == chickens.length){
//            通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

//      如果容器没有满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;

//        可以通知消费者消费
        this.notifyAll();

    }

//    消费者消费产品
    public synchronized Chicken pop(){
//        判断能否消费
        if (count == 0){
//            等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        如果可以消费
        count--;
        Chicken chicken = chickens[count];

//        我吃完了，通知生产者生产
        this.notifyAll();

        return chicken;
    }
}

信号灯法

package day04;

import day02.Person;

import java.util.Timer;

//测试：生产者消费者问题2：信号灯法，标志位解决
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();

        new Player(tv).start();

        new Watcher(tv).start();
    }

}

//生产者--->演员
class Player extends Thread{
    TV tv;

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

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2 == 0){
                this.tv.play("快乐大本营播放中！！！");
            }else {
                this.tv.play("抖音：记录美好生活。。。");
            }
        }
    }
}

//消费者--->观众
class Watcher extends Thread{
    TV tv;

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

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

//产品--->节目
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.notifyAll();

        this.voice = voice;
        this.flag = !this.flag;
    }
//    观看
    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了："+voice);

//        通知演员表演
        this.notifyAll();
    }
}

线程池

package day04;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
//        1。创建服务。创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

//        执行
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        
//        关闭链接
        executorService.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

多线程详解

原文：https://www.cnblogs.com/ZweiShen/p/14292282.html