java多线程

最新推荐文章于 2022-07-19 10:05:32 发布
原创 最新推荐文章于 2022-07-19 10:05:32 发布 · 169 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #多线程

1.什么是多线程

现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务，而CPU执行代码都是一条一条顺序执行的，但是，即使是单核cpu，也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行。

进程：

在计算机中，我们把一个任务称为一个进程，浏览器就是一个进程，视频播放器是另一个进程，类似的，音乐播放器和Word都是进程。

进程和线程的关系：

一个进程可以包含一个或多个线程，但至少会有一个线程。

多进程模式（每个进程只有一个线程）

多线程模式（一个进程有多个线程）

多进程+多线程模式

多进程稳定性比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。

注意：

  • 在程序运行时，即使自己没有创建线程，后台也会有多个线程，如主线程、gc线程
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后新顺序是不能人为干预的

2.创建新线程

主线程调用run方法和start方法的区别

在这里插入图片描述

2.1 方法一（继承Thread类）

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

线程不一定立即执行，由CPU安排调度

package multithreading.lesson01;

// 创建线程：继承Tread类，重写run（）方法，调用start开启线程
public class CreateThread extends Thread {
    @Override
    public void run() {
        // run（）方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println(i + "start new thred");
        }
    }

    public static void main(String[] args) {// main线程，主线程
        // 创建一个线程对象
        CreateThread createThread = new CreateThread();
        // 调用start方法开启线程
        createThread.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println(i + "main 线程");
        }
    }
}

调用start方法，主线程和子线程并行交替进行

在这里插入图片描述

2.2 方法二（实现Runnable接口）

  • 自定义线程类实现Runnable接口
  • 重写run（）方法，编写线程执行体
  • 创建线程对象（Thread），传入一个Runnable实例，调用start（）方法启动线程
package multithreading.lesson01;

// 创建：实现Runnable接口，重写run方法，执行线程需要传入Runnable接口实现类，调用start开启线程
public class CreateThread2 implements Runnable {
    @Override
    public void run() {
        // run（）方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println(i + "start new thred");
        }
    }

    public static void main(String[] args) {// main线程，主线程
        //创建Runnable接口的实现类对象
        CreateThread2 createThread2 = new CreateThread2();
        // 创建线程对象，通过线程对象开启线程（代理）
        Thread thread = new Thread(createThread2);
        // 调用start（）方法开启线程
        thread.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println(i + "main 线程");
        }
    }
}

调用start方法，主线程和子线程并行交替进行

在这里插入图片描述

2.3 总结

1.方法一：继承Thread类

  • 子类继承Thread类具备多线程的能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP单继承局限性

2.方法二：实现Runnable接口

  • 实现Runnable接口具有多线程能力
  • 启动线程：new Thread（Runnable实例）.start()
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

【示例】

package multithreading.lesson01;

public class TestThread implements Runnable {
    private int ticketNUM = 10;

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

    public static void main(String[] args) {
        TestThread testThread = new TestThread();

        new Thread(testThread, "张三").start();
        new Thread(testThread, "李四").start();
        new Thread(testThread, "黄牛党").start();
    }
}

在这里插入图片描述

3.lambda表达式

可以通过lambda表达式来创建函数式接口的对象

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

代码简化过程：

  • 实现类
  • 静态内部类
  • 局部内部类
  • 匿名内部类
  • 使用lambda表达式
package multithreading.lambda;

public class Test01 {
    // 2.静态内部类
    static class Student2 implements Action {
        @Override
        public void sleep() {
            System.out.println("我在睡觉2");
        }
    }

    public static void main(String[] args) {
        Action student = new Student1();// 通过实现类
        student.sleep();
        student = new Student2();// 通过静态内部类
        student.sleep();
        // 3.局部内部类
        class Student3 implements Action {
            @Override
            public void sleep() {
                System.out.println("我在睡觉3");
            }
        }
        student = new Student3();// 通过局部内部类
        student.sleep();
        // 4.匿名内部类：没有类的名称，必须借助接口或者父类
        student = new Action() {// 通过匿名内部类
            @Override
            public void sleep() {
                System.out.println("我在睡觉4");
            }
        };
        student.sleep();
        // 6.使用lamdba简化
        student = () -> {
            System.out.println("我在睡觉5");
        };
        student.sleep();
    }


}

// 定义一个函数式接口
interface Action {
    void sleep();
}

// 1.实现类
class Student1 implements Action {
    @Override
    public void sleep() {
        System.out.println("我在睡觉1");
    }
}
执行结果：
我在睡觉1
我在睡觉2
我在睡觉3
我在睡觉4
我在睡觉5

lambda表达式简化

package multithreading.lambda;

public class Test02 {
    public static void main(String[] args) {
        Food egg = null;
        // 1.lamdba表达式
        egg = (int a)->{
            System.out.println("我吃了"+a+"个鸡蛋");
        };
        egg.eat(3);
        // 2.简化参数类型
        egg = (a)->{
            System.out.println("我吃了"+a+"个鸡蛋");
        };
        egg.eat(5);
        // 3.简化小括号
        egg = a->{
            System.out.println("我吃了"+a+"个鸡蛋");
        };
        egg.eat(7);
        // 4.简化大括号
        egg = a->System.out.println("我吃了"+a+"个鸡蛋");
        egg.eat(9);
    }
}
interface Food {
    void eat(int n);
}
执行结果：
我吃了3个鸡蛋
我吃了5个鸡蛋
我吃了7个鸡蛋
我吃了9个鸡蛋

注意：

  • lambda表达式只能当方法中只有一行代码时，才能去掉大括号；如果有多行代码，则不能简化大括号
  • lambda表达式实现的前提是函数式接口
  • 如果有多个参数也可以去掉参数类型，但是要去掉就必须全部去掉，不能简化小括号

【lambda表达式实际应用示例】

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); // 启动新线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("start new thread!");
    }
}
执行结果：
start new thread!

Java8引入的lambda语法进一步简写为：

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("start new thread!");
        });
        t.start(); // 启动新线程
    }
}
执行结果：
start new thread!

4.静态代理模式

【示例】：结婚

  • 结婚的人（真实对象）：zhangsan
  • 婚庆公司（代理对象）：company
  • 共同的行为：Marry
package multithreading.lesson01;
/*
静态代理模式：
结婚的人和婚庆公司都实现Marry接口
婚庆公司代理结婚的人（代理对象代理真实角色）
 */
/*
好处：
代理对象可以做很多真实对象做不了的事情，而真实对象只用专注做自己的事情
 */

public class Test {
    public static void main(String[] args) {
        Person zhangsan = new Person();
        Company company = new Company(zhangsan);
        company.getMarry();

    }
}

interface Marry {
    void getMarry();
}

// 实际角色（结婚的人）
class Person implements Marry {
    @Override
    public void getMarry() {
        System.out.println("我结婚了");
    }
}

// 代理角色（婚庆公司）
class Company implements Marry {
    private Marry target;// 结婚的对象

    // 构造方法
    public Company(Marry target) {
        this.target = target;
    }

    @Override
    public void getMarry() {
        before();
        this.target.getMarry();// 调用的是getMarry()是Peson中的
        after();

    }

    // 婚庆公司自有的结婚流程
    private void before() {
        System.out.println("结婚之前，布置场地");
    }

    // 婚庆公司自有的结婚流程
    private void after() {
        System.out.println("结婚之后，收取尾款");
    }
}
执行结果：
结婚之前，布置场地
我结婚了
结婚之后，收取尾款

Runnable和Thread的代理模式

我们在使用Runnable接口实现多线程的时候启动必须借助Thread类对象，我们将这个Thread对象称之为代理对象

Thread实现了Runnable接口

public static void main(String[] args) {
    Person zhangsan = new Person();
    // Company为代理对象，真实对象是zhangsan实现了Marry接口
    Company company = new Company(zhangsan);
    company.getMarry();
    // Thread为代理对象，真实对象是hahhah实现了Runnable接口
    Thread thread = new Thread(()-> System.out.println("hahhah"));
    thread.start();
}

5.操作线程

5.1 线程停止（stop）

不推荐使用JDK提供的stop()、destroy()方法（已废弃），推荐线程自己停下来，建议使用一个标志位进行终止变量：当flag=false，则终止线程运行。

package multithreading.lesson02;

public class Test01 implements Runnable {
    // 1.线程中定义线程体使用的标志位
    private boolean flag = true;

    @Override
    public void run() {
        // 2.线程体中使用该标志位
        while (flag) {
            System.out.println("线程运行中……");
        }
    }

    // 自定义stop方法来改变标志位
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        Test01 test = new Test01();
        new Thread(test).start();
        for (int i = 0; i < 200000; i++) {
            if (i == 90000) {
                test.stop();
                System.out.println("线程停止了");
            }
        }
    }
}

在这里插入图片描述

5.2 线程休眠（sleep）

  • sleep（时间）指定当前线程阻塞的毫秒数
  • sleep存在异常InterruptException
  • sleep时间结束后，线程进入就绪状态
  • sleep可以模拟网络延时，倒计时等
  • 每个对象都有一个锁，sleep不会释放锁
package multithreading.lesson02;

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

public class TestSleep {
    // 十秒倒计时
    public static void countDown() throws InterruptedException {
        for (int i = 10; i > 0; i--) {
            System.out.println(i);
            Thread.sleep(1000);
        }
    }

    // 打印当前时间
    public static void printTime() throws InterruptedException {
        Date time = new Date(System.currentTimeMillis());// 获取系统当前时间
        for (int i = 10; i > 0; i--) {
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(time));
            Thread.sleep(1000);
            time = new Date(System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        try {
            countDown();
            printTime();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

5.3 线程礼让（yield）

  • 线程礼让，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让CPU重新调度，礼让不一定成功！取决于CPU
package multithreading.lesson02;

public class TestYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程--->开始执行");
        Thread.yield();// 礼让
        System.out.println(Thread.currentThread().getName() + "线程--->停止执行");
    }

    public static void main(String[] args) {
        TestYield testYield = new TestYield();
        new Thread(testYield, "A").start();
        new Thread(testYield, "B").start();
        new Thread(testYield, "C").start();
    }
}
执行结果：（礼让不一定成功）
A线程--->开始执行
B线程--->开始执行
B线程--->停止执行
C线程--->开始执行
A线程--->停止执行
C线程--->停止执行

5.4 线程插队（join）

join合并线程，当此线程执行完成后，再执行其他线程，其他线程处于阻塞的状态

package multithreading.lesson02;

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(i + "线程VIP来了……");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        for (int i = 0; i < 100; i++) {
            System.out.println(i + "主线程运行中");
            if (i == 20) {
                thread.start();// 线程开始执行
                thread.join();// 线程插队
            }
        }
    }
}

在这里插入图片描述

5.5 线程状态

在Java程序中，一个线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()方法执行完毕，线程就结束了。因此，Java线程的状态有以下几种：

  • New：新创建的线程，尚未执行；
  • Runnable：运行中的线程，正在执行run()方法的Java代码；
  • Blocked：运行中的线程，因为某些操作被阻塞而挂起；
  • Waiting：运行中的线程，因为某些操作在等待中；
  • Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；
  • Terminated：线程已终止，因为run()方法执行完毕。
package multithreading.lesson02;

public class TestStatus {
    public static void main(String[] args) {
        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();
        state = thread.getState();
        System.out.println(state);

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

在这里插入图片描述

5.6 线程优先级

  1. Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

  2. 线程的优先级用数字表示，范围从1~10

  • Thread.MIN_PRIORITY = 1;
  • Thread.MAX_PRIORITY = 10;
  • Thread.NORM_PRIORITY = 5;
  1. 使用以下方式改变和获取优先级
getPriority();
setPriority(×××);

注意：

先设置优先级，再启动线程

优先级低只意味着获得调度的概率低，并不是优先级低就不会被调用，这都是看CPU的调度

5.7 线程守护（daemon）

  • 线程分为用户线程和守护线程

    如用户线程：主函数main方法；守护线程：垃圾回收gc()

  • 虚拟机必须确保用户线程执行完毕，不用等待守护线程执行完毕

package multithreading.lesson02;

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        Person person = new Person();
        Thread thread = new Thread(god);
        thread.setDaemon(true);// 默认是false，表示用户线程（正常的线程都是用户线程）
        thread.start();// 启动god守护线程
        new Thread(person).start();
    }
}

class God implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("God bless you");
        }
    }
}

class Person implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我还活着…………");
        }
        System.out.println("I was dead");
    }
}

在这里插入图片描述

6.线程同步

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步。

线程同步其实就是一种等待机制，多个需要同时访问此对象的进程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

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

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

6.1 同步方法

synchronized方法控制控制"对象"的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

public synchronized void method(int args) {……}

package multithreading.lesson03;

public class TicketGrabbing {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(ticket, "张三").start();
        new Thread(ticket, "电脑").start();
        new Thread(ticket, "黄牛党").start();
    }
}

class Ticket implements Runnable {
    private int ticketNUM = 20;
    private boolean flag = true;

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

    public synchronized void buy() {
        if (ticketNUM <= 0) {
            flag = false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "----抢到了第" + ticketNUM + "张票");
        ticketNUM--;
    }
}

在这里插入图片描述

6.2 同步块

synchronized (Obj) {}

Obj称之为同步监视器：

  • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
  • 同步方法中无须指定同步监视器，因为同步方法的同步监视器就是this，即对象本身或者class

同步监视器的执行过程：

  1. 第一个线程访问，锁定同步监视器，执行其中代码
  2. 第二个线程访问，发现同步监视器被锁定，无法访问
  3. 第一个线程访问完毕，解锁同步监视器
  4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

谁变就同步谁

package multithreading.lesson03;

public class Money {
    public static void main(String[] args) {
        // 创建账户
        User user = new User("基金", 1000);
        Bank boy = new Bank(user, 200, "张三");// 取200
        Bank police = new Bank(user, 150, "警察");// 取150
        boy.start();
        police.start();
    }
}

// 账户
class User {
    String name;// 银行卡用户名
    int cardBalance;// 银行卡余额

    public User(String name, int cardBalance) {
        this.name = name;
        this.cardBalance = cardBalance;
    }
}

// 银行：模拟取款
class Bank extends Thread {
    User user;// 账户
    int drawingMoney;// 单次取了多少钱
    int totalDrawingMoney;// 一共取了多少钱

    public Bank(User user, int drawingMoney, String name) {
        super(name);
        this.user = user;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        synchronized (user) {
            // 判断卡内余额不够取
            if (user.cardBalance - drawingMoney < 0) {
                System.out.println("卡内余额不足");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            user.cardBalance = user.cardBalance - drawingMoney;
            totalDrawingMoney = totalDrawingMoney + drawingMoney;
            // Thread.currentThread().getName() 等同于 this.getName()
            System.out.println(Thread.currentThread().getName() + "取了：" + drawingMoney);
            System.out.println(this.getName() + "手里的钱：" + totalDrawingMoney);
            System.out.println("卡内余额：" + user.cardBalance);
        }
    }
}
执行结果：
张三取了：200
张三手里的钱：200
卡内余额：800
警察取了：150
警察手里的钱：150
卡内余额：650

7.死锁

多个线程各自占有一些共享资源﹐并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形

某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

7.1 死锁示例

一个线程可以获取一个锁后，再继续获取另一个锁。

线程启动：

  • 线程1：张三----->进入possess()，获得fish锁（持续1秒）

  • 线程2：王警官–>进入possess()，获得bearsPaw锁（持续3秒）

随后：

  • 线程1：张三----->准备获得bearsPaw锁，失败，等待中

  • 线程2：王警官–>准备获得fish锁，失败，等待中

此时，两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

choose == 1：获得fish的锁后再获得bearsPaw的锁

choose == 2：获得bearsPaw的锁后再获得fish的锁

package multithreading.lesson03;

public class DeadLock {
    public static void main(String[] args) {
        new Person("张三", 1).start();
        new Person("王警官", 2).start();
    }
}

// 鱼
class Fish {
}

// 熊掌
class BearsPaw {
}

class Person extends Thread {
    // 需要的资源只有一份，用static来保证只有一份
    static Fish fish = new Fish();
    static BearsPaw bearsPaw = new BearsPaw();

    String name;
    int choose;

    public Person(String name, int choose) {
        this.name = name;
        this.choose = choose;
    }

    @Override
    public void run() {
        possess();

    }

    public void possess() {
        if (choose == 1) {
            synchronized (fish) {
                System.out.println(this.name + "获得鱼的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (bearsPaw) {
                    System.out.println(this.name + "获得熊掌的锁");
                }
            }
        }
        if (choose == 2) {
            synchronized (bearsPaw) {
                System.out.println(this.name + "获得熊掌的锁");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (fish) {
                    System.out.println(this.name + "获得鱼的锁");
                }
            }
        }
    }
}

注意：死锁发生后，没有任何机制能解除死锁，只能强制结束JVM进程。

在编写多线程应用时，要特别注意防止死锁。因为死锁一旦形成，就只能强制结束进程

7.2 解决办法

  1. 线程获取锁的顺序要一致。即严格按照先获取fish，再获取bearsPaw的顺序
  2. 将fish锁和bearsPaw锁分开写，不要嵌套，顺序可以不一样
public void possess() {
    if (choose == 1) {
        synchronized (fish) {
            System.out.println(this.name + "获得鱼的锁");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (bearsPaw) {
                System.out.println(this.name + "获得熊掌的锁");
            }
        }
    }
    if (choose == 2) {
        synchronized (fish) {
            System.out.println(this.name + "获得鱼的锁");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (bearsPaw) {
                System.out.println(this.name + "获得熊掌的锁");
            }
        }
    }
}

public void possess() {
    if (choose == 1) {
        synchronized (fish) {
            System.out.println(this.name + "获得鱼的锁");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        synchronized (bearsPaw) {
            System.out.println(this.name + "获得熊掌的锁");
        }
    }
    if (choose == 2) {
        synchronized (bearsPaw) {
            System.out.println(this.name + "获得熊掌的锁");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        synchronized (fish) {
            System.out.println(this.name + "获得鱼的锁");
        }
    }
}

7.3 产生死锁的必要条件

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

以上为死锁的四个必要条件，只要想办法破其中的任意一个或者多个条件就可以避免死锁的发生

8.Lock

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

加锁：new ReentrantLock().lock();

解锁：new ReentrantLock().unlock();

class A{
    // 定义Lock锁
    private final ReentrantLock reentrantLock = new ReentrantLock();

    public void method() {
        while (true) {
            reentrantLock.lock();// 加锁
            try {
                // 保证线程安全的代码……
            }
            finally {
                reentrantLock.unlock();// 解锁
            }
        }
    }
}

package multithreading.lesson03;

import java.util.concurrent.locks.ReentrantLock;

public class Lock {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();
        new Thread(tickets).start();
        new Thread(tickets).start();
        new Thread(tickets).start();
        new Thread(tickets).start();
    }
}

class Tickets implements Runnable {
    int tickes = 10;
    // 定义Lock锁
    private final ReentrantLock reentrantLock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            reentrantLock.lock();// 加锁
            try {
                if (tickes <= 0) {
                    return;
                }
                System.out.println(tickes--);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();// 解锁
            }

        }
    }
}
执行结果：
10
9
8
7
6
5
4
3
2
1

synchronized 与Lock的对比

  • Lock是显式锁（手动开启和关闭锁，别忘记关闭锁) ；sygchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁；synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
  • 优先使用顺序:
    Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法（在方法体之外)

9.wait和notify

wait和notify用于多线程协调运行：

  • 在synchronized内部可以调用wait()使线程进入等待状态；
  • 必须在已获得的锁对象上调用wait()方法；
  • 在synchronized内部可以调用notify()或notifyAll()唤醒其他等待线程；
  • 必须在已获得的锁对象上调用notify()或notifyAll()方法；
  • 已唤醒的线程还需要重新获得锁后才能继续执行。

使用notifyAll()将唤醒所有当前正在this锁等待的线程，而notify()只会唤醒其中一个（具体哪个依赖操作系统，有一定的随机性）

使用notifyAll()将一次性全部唤醒。通常来说，notifyAll()更安全。有些时候，如果我们的代码逻辑考虑不周，用notify()会导致只唤醒了一个线程，而其他线程可能永远等待下去醒不过来了。

调用wait()方法后，线程进入等待状态，wait()方法不会返回，直到将来某个时刻，线程从等待状态被其他线程唤醒后，wait()方法才会返回，然后，继续执行下一条语句。

package multithreading.lesson04;


public class Test01 {
    public static void main(String[] args) {
        Warehouse warehouse = new Warehouse();
        new Producer(warehouse).start();
        new Consumer(warehouse).start();
    }
}

// 生产者
class Producer extends Thread {
    Warehouse warehouse;

    public Producer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out.println("工具人生产了第" + i + "个玩具");
            warehouse.push(new Toy(i));
        }
    }
}

// 消费者
class Consumer extends Thread {
    Warehouse warehouse;

    public Consumer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out.println("张三购买了第" + warehouse.buy().id + "个玩具");
        }
    }
}

// 玩具（产品）
class Toy {
    int id;

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

// 仓库（缓冲器）
class Warehouse {
    // 定义一个放玩具的容器
    Toy[] toys = new Toy[10];
    // 容器计数器
    int count = 0;

    // 生产者放入产品（）
    public synchronized void push(Toy toy) {
        // 判断容器是否存满
        if (count == toys.length) {
            // 如果容器存满，就等待消费者购买
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        // 如果容器没有存满，生产者就继续放入产品
        toys[count] = toy;
        count++;
        // 通知消费者购买产品
        this.notifyAll();
    }

    // 消费者购买产品
    public synchronized Toy buy() {
        // 判断容器内是否有产品
        if (count == 0) {
            // 如果容器中没有产品，即不能消费，则等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 如果容器中有产品，消费者就可以购买产品
        count--;
        Toy toy = toys[count];
        // 通知生产者生产产品
        this.notifyAll();
        return toy;
    }
}

10.线程池

Java语言虽然内置了多线程支持，启动一个新线程非常方便，但是，创建线程需要操作系统资源（线程资源，栈空间等），频繁创建和销毁大量线程需要消耗大量时间。

Java标准库提供了ExecutorService接口表示线程池

package multithreading.lesson04;

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

public class Pool {
    public static void main(String[] args) {
        // 1.创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        // 2.执行
        service.execute(new Person());
        service.execute(new Person());
        service.execute(new Person());
        service.execute(new Person());
        // 3.关闭线程池
        service.shutdown();
    }
}

class Person implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
执行结果：
pool-1-thread-2
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4

品，即不能消费，则等待生产者生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果容器中有产品，消费者就可以购买产品
count–;
Toy toy = toys[count];
// 通知生产者生产产品
this.notifyAll();
return toy;
}
}


## 10.线程池

Java语言虽然内置了多线程支持，启动一个新线程非常方便，但是，创建线程需要操作系统资源（线程资源，栈空间等），频繁创建和销毁大量线程需要消耗大量时间。

Java标准库提供了`ExecutorService`接口表示线程池

~~~java
package multithreading.lesson04;

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

public class Pool {
    public static void main(String[] args) {
        // 1.创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        // 2.执行
        service.execute(new Person());
        service.execute(new Person());
        service.execute(new Person());
        service.execute(new Person());
        // 3.关闭线程池
        service.shutdown();
    }
}

class Person implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
执行结果：
pool-1-thread-2
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
构建多线程应用程序2 Parallel 并行类：Parallel.ForEach()、Task异步操作类：Task.Factory.StartNew()、并行LINQ查询： AsParallel()
Java_c#
01-05 3637
public partial class Form3 : Form { /// &lt;summary&gt; /// 主线程 /// &lt;/summary&gt; private Task taskMain; /// &lt;summary&gt; /// 主线程退出对象 ...
一台 Java 服务器可以跑多少个线程？
微微笑
08-20 459
每个线程都有一个线程栈空间通过-Xss设置，查了一下我们服务器的关于jvm内存的配置 -Xms4096m -Xmx4096m -XX:MaxPermSize=1024m 只有这三个，并没有-Xss 和-XX:ThreadStackSize的配置，因此是走的默认值。几种JVM的默认栈大小 不考虑系统限制，可以通过如下公式计算，得出最大线程数量 线程数量=（机器本身可用内存-JVM分配的堆内存）/Xss的值，比如我们的容器本身大小是8G,堆大小是40...
java 线程 furtu,c#多线程操作测试（阻塞线程，结束任务）
weixin_39600616的博客
03-20 144
usingSystem;usingSystem.Collections.Generic;usingSystem.ComponentModel;usingSystem.Data;usingSystem.Drawing;usingSystem.Linq;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;usingSys...
java 线程基本用法
weixin_33737134的博客
08-17 127
java中的多线程 一、java线程基本介绍 1、进程与线程的区别 进程是指一个内存中运行的应用程序，每个进程都有一块独立的内存空间，一个进程包含一到多个线程。 每个线程都有他所属的进程，每个线程也就是该进程的一条执行路...
Task.Run 和 Task.Factory.StartNew 之间的区别
君子居易
07-19 3603
在本文中，我们了解了Task.Run和Task.Factory.StartNew之间的区别。我们已经讨论了一些高级用例，哪些StartNew是可行的选择，否则Task.Run通常是推荐的方法。
Java启动新线程的额外开销
u012604322的专栏
03-19 2636
在启动一个新线程的时候会有一定时间的额外开销，因此并不是所有情况下都应使用多线程。如下的代码段进行简单实验探讨：
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
JAVA多线程技术分享-39页PPT(winding)
05-10
Java多线程技术是软件开发中的重要组成部分，尤其在高并发场景下不可或缺。本文将深入探讨多线程技术的关键知识点，以及在实际开发中容易遇到的问题。 首先，基础概念是理解多线程的关键。`Thread.sleep(0)`看似无...
java线程工厂
beirdu的专栏
12-11 575
Thread构造函数　　java的Thread类构造函数打字分为三类，我们可以认为线程工程基本元素基于则三个元素—— 　　 构造参数中指定线程名称； 构造参数为Runnable/或者其实现类； 构造参数指定所在线程组； 以上三个中元素时有多种排列组合，可以混用的 //每种一个示例： public Thread(Runnable target) { init(null, t
Task.Factory.StartNew 测试
qq_35382207的博客
04-29 6313
到底该用多少线程？线程数、CPU核心数、本地计算时间、等待时间的关系 线程数 = CPU核心数 * ( 本地计算时间 + 等待时间 ) / 本地计算时间 下面是Task.Factory.StartNew和自己写的TaskHelper.LargeTask.Run对比测试 一、Task.Factory.StartNew 使用 TaskCreationOptions.LongRunning...
Task创建任务的几种方法
小目标一个亿
05-11 8379
首先介绍一下Task，Task有什么用，说白了Task就是线程池ThreadPool的升级版，它弥补了ThreadPool的一些不足，比如说ThreadPool不支持线程的取消、完成、失败通知、执行的先后顺序等等，要实现这些功能需要完成额外的工作。 创建task的方式有很多，我在这先简单介绍几种 方式一：先创建，后执行 Task task = new Task(() => { //方法体 }); task.Start(); 方式二：创建并执行 Task task = Ta
JavaFX中javafx.concurrent.Task类的使用
08-27 6717
JavaFX中处理比较耗时的任务或操作，在不阻塞UI线程的情况下需要用到javafx.concurrent.Task类和Thread类配合使用，以下是调用示例： Task task = new Task() { @Override protected Integer call() throws Exception {
线程Thread类的start()方法和run()方法
weixin_34235135的博客
05-26 2127
一、初识 java的线程是通过java.lang.Thread类来实现的。VM启动时会有一个由主方法所定义的线程。可以通过创建Thread的实例来创建新的线程。每个线程都是通过某个特定Thread对象所对应的方法run（）来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。 在Java当中，...
java线程的start方法_Java线程中的run和start方法
weixin_36327582的博客
02-26 527
刚开始接触线程的时候，只是生硬的记住了如果要启动一个线程必须调用该线程的start方法，可是由于刚开始不经常使用多线程方面的知识，所以渐渐的就模糊了，现在常常碰到多线程的使用，知其然知其所以然嘛，今天就从源码方面探究一下。run方法查看一下JDK的源码，可以看到Thread中的run方法调用的是Runnable中run：private Runnable target;public void run...
多线程中的Join
柯基的博客
09-16 2917
线程中join(强制执行)：当前线程执行完毕之后，才会执行后面程序，其他线程阻塞； 实例： public class ThreadJoin implements Runnable{ @Override public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Join..."+i+"运行中"); } } public stat
Java多线程编程详解
"深入总结了Java多线程编程的文档，包含83页详细内容，适合学习和理解Java线程机制。" 在Java编程中，多线程是一个关键特性，允许程序同时执行多个任务，提高效率和响应性。本文档详细探讨了Java中线程的概念、原理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值