文章/答案/技术大牛

发布

社区首页 >专栏 >Java学习笔记（多线程相关知识）

Java学习笔记（多线程相关知识）

用户5513909

发布于 2023-04-25 03:15:13

19500

代码可运行

文章被收录于专栏：小鱼儿我的学习笔记小鱼儿我的学习笔记

运行总次数：0

代码可运行

多线程的概述

进程：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 进程的三个特征： 1.动态性：进程是运行中的程序，要动态的占用内存，CPU和网络等资源。 2.独立性：进程与进程之间是相互独立的，彼此有自己的独立内存区域。 3.并发性：假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常快，给我们的感觉这些进程在同时执行，这就是并发性。
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

多线程的创建方式

我们在进程中创建线程的方式有三种: （1）直接定义一个类继承线程类Thread，重写run()方法，创建线程对象调用线程对象的start()方法启动线程。（2）定义一个线程任务类实现Runnable接口，重写run()方法，创建线程任务对象，把线程任务对象包装成线程对象，调用线程对象的start()方法启动线程。（3）实现Callable接口（拓展）。

方式一

方式：继承Thread类的方式 1.定义一个线程类继承Thread类。 2.重写run()方法 3.创建一个新的线程对象。 4.调用线程对象的start()方法启动线程。

优缺点：

优点：编码简单。
缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓（单继承的局限性）小结：
线程类是继承了Thread的类。
启动线程必须调用start()方法。
多线程是并发抢占CPU执行，所以在执行的过程中会出现并发随机性

public class ThreadDemo {
    // 启动后的ThreadDemo当成一个进程。
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args) {
        // 3.创建一个线程对象
        Thread t = new MyThread();
        // 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！
        t.start();

        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("main线程输出："+i);
        }
    }
}

// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
    // 2.重写run()方法
    @Override
    public void run() {
        // 线程的执行方法。
        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("子线程输出："+i);
        }
    }
}

方式二

方式：实现Runnable接口的方式。 1.创建一个线程任务类实现Runnable接口。 2.重写run()方法 3.创建一个线程任务对象。 4.把线程任务对象包装成线程对象 5.调用线程对象的start()方法启动线程。

Thread的构造器：

public Thread(){}
public Thread(String name){}
public Thread(Runnable target){}
public Thread(Runnable target, String name){}

缺点：

代码复杂一点。

优点：

线程任务类只是实现了Runnable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
同一个线程任务对象可以被包装成多个线程对象
适合多个多个线程去共享同一个资源（后面内容）
实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
线程池可以放入实现Runable或Callable线程任务对象。注意：其实Thread类本身也是实现了Runnable接口的。
不能直接得到线程执行的结果！

public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)
        Runnable target = new MyRunnable();
        // 4.把线程任务对象包装成线程对象.且可以指定线程名称
        // Thread t = new Thread(target);
        Thread t = new Thread(target,"1号线程");
        // 5.调用线程对象的start()方法启动线程
        t.start();

        Thread t2 = new Thread(target);
        // 调用线程对象的start()方法启动线程
        t2.start();

        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}

// 1.创建一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
    // 2.重写run()方法
    @Override
    public void run() {
        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}

方式三

方法：实现Callable接口

1.定义一个线程任务类实现Callable接口，申明线程执行的结果类型。 2.重写线程任务类的call方法，这个方法可以直接返回执行的结果。 3.创建一个Callable的线程任务对象。 4.把Callable的线程任务对象包装成一个未来任务对象。 5.把未来任务对象包装成线程对象。 6.调用线程的start()方法启动线程

优点：

线程任务类只是实现了Callable接口，可以继续继承其他类，而且可以继续实现其他接口（避免了单继承的局限性）
同一个线程任务对象可以被包装成多个线程对象
适合多个多个线程去共享同一个资源
实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立。
线程池可以放入实现Runable或Callable线程任务对象。
能直接得到线程执行的结果！缺点：
编码复杂。

public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个Callable的线程任务对象
        Callable call = new MyCallable();
        // 4.把Callable任务对象包装成一个未来任务对象
        //      -- public FutureTask(Callable<V> callable)
        // 未来任务对象是啥，有啥用？
        //      -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
        //      -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
        FutureTask<String> task = new FutureTask<>(call);
        // 5.把未来任务对象包装成线程对象
        Thread t = new Thread(task);
        // 6.启动线程对象
        t.start();

        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
        }

        // 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
        try {
            String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
            System.out.println(rs);
        }  catch (Exception e) {
            e.printStackTrace();
        }

    }
}

// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable<String>{
    // 2.重写线程任务类的call方法！
    @Override
    public String call() throws Exception {
        // 需求：计算1-10的和返回
        int sum = 0 ;
        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
            sum+=i;
        }
        return Thread.currentThread().getName()+"执行的结果是："+sum;
    }
}

线程安全

线程安全问题：多个线程同时操作同一个共享资源的时候可能会出现线程安全问题。

/**
    模拟出取款问题的案例：
        注意：用高度面向对象的思想设计。
        分析：
            （1）提供一个账户类Account.java作为创建共享资源账户对象的类。
            （2）定义一个线程类来用于创建2个线程分别代表小明和小红来取钱。
    小结：
        多个线程同时操作同一个共享资源的时候可能会出现线程安全问题。
 */
public class ThreadSafe {
    public static void main(String[] args) {
        // a.创建一个共享资源账户对象！
        Account acc = new Account("ICBC-110" , 100000);

        // b.创建2个线程对象去账户对象中取钱
        Thread littleMing = new DrawThread(acc,"小明");
        littleMing.start();

        Thread litterRed = new DrawThread(acc,"小红");
        litterRed.start();
    }
}

// 线程类：创建取钱线程对象的。
public class DrawThread extends Thread{
    // 定义一个成员变量接收账户对象
    private Account acc ;
    public DrawThread(Account acc,String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        // 小明 小红
        // 取钱100000
        acc.drawMoney(100000);
    }
}

public class Account {
    private String cardID;
    private double moeny;

    // 小明线程/小红线程
    public void drawMoney(double moeny) {
        // 开始判断取钱逻辑
        // 1.先知道是谁来取钱
        String name = Thread.currentThread().getName();
        // 2.判断余额是否足够
        if(this.moeny >= moeny){
            System.out.println(name+"来取钱，余额足够，吐出"+moeny);
            // 3.更新余额
            this.moeny -= moeny;
            System.out.println(name+"来取钱后，余额剩余"+ this.moeny);
        }else{
            System.out.println(name+"来取钱，余额不足！");
        }
    }

    public Account() {
    }

    public Account(String cardID, double moeny) {
        this.cardID = cardID;
        this.moeny = moeny;
    }

    public String getCardID() {
        return cardID;
    }

    public void setCardID(String cardID) {
        this.cardID = cardID;
    }

    public double getMoeny() {
        return moeny;
    }

    public void setMoeny(double moeny) {
        this.moeny = moeny;
    }
}

解决方案：线程同步

线程同步的作用：就是为了解决线程安全问题的方案。

线程同步解决线程安全问题的核心思想：

让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

线程同步的做法：加锁是把共享资源进行上锁，每次只能一个线程进入访问完毕以后，其他线程才能进来。线程同步的方式有三种： 1.同步代码块。 2.同步方法。 3.lock显示锁。

方式一：同步代码块

作用：把出现线程安全问题的核心代码给上锁，每次只能一个线程进入执行完毕以后自动解锁，其他线程才可以进来执行。格式： synchronized(锁对象){ // 访问共享资源的核心代码 } 锁对象：理论上可以是任意的“唯一”对象即可。原则上：锁对象建议使用共享资源。

在实例方法中建议用this作为锁对象。此时this正好是共享资源！必须代码高度面向对象
在静态方法中建议用类名.class字节码作为锁对象。

public class ThreadSafe {
    public static void main(String[] args) {
        // 入口类：
        // 1.创建一个共享的账户对象（共享资源），账户对象必须只创建一个。
        Account acc = new Account(10000, "ICBC-110");

        // 2.创建2个线程对象代表：小明和小红。
        Thread xiaoMing = new DrawThread(acc,"小明");
        xiaoMing.start();

        Thread xiaoRed = new DrawThread(acc,"小红");
        xiaoRed.start();
    }
}

public class DrawThread extends Thread {
    private Account acc ; // 定义了一个账户类型的成员变量接收取款的账户对象！
    public DrawThread(Account acc , String name){
        super(name); // 为当前线程对象取名字
        this.acc = acc;
    }

    @Override
    public void run() {
        // 小明/小红
        acc.drawMoney(10000);
    }
}

public class Account {
    private double money ; // 余额
    private String cardId ;
    public Account(){

    }
    public Account(double money, String cardId) {
        this.money = money;
        this.cardId = cardId;
    }
    // 小明、小红执行到此
    public void drawMoney(double money) {
        // 1.先拿到是谁来取钱：取当前线程对象的名称
        String name = Thread.currentThread().getName();
        // 小明、小红
        // this == 当前共享账户acc
        // 2.判断余额是否足够
        synchronized (this){
            if(this.money >= money){
                // 3.余额足够
                System.out.println(name+"来取钱，吐出："+money);
                // 4.更新余额
                this.money -= money;
                // 5.输出结果
                System.out.println(name+"来取钱"+money+"成功，取钱后剩余："+this.money);
            }else{
                // 6.余额不足
                System.out.println(name+"来取钱，余额不足，剩余"+this.money);
            }
        }
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
}

方式二：同步方法

作用：把出现线程安全问题的核心方法给锁起来，每次只能一个线程进入访问，其他线程必须在方法外面等待。

用法：直接给方法加上一个修饰符 synchronized

原理:

同步方法的原理和同步代码块的底层原理其实是完全一样的，只是
同步方法是把整个方法的代码都锁起来的。
同步方法其实底层也是有锁对象的：
如果方法是实例方法：同步方法默认用this作为的锁对象。
如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

public class ThreadSafe {
    public static void main(String[] args) {
        // a.创建一个账户对象。
        Account acc = new Account(10000,"ICBC-110" );
        // b.定义一个线程类创建2个线程代表小明和小红
        Thread xiaoMing = new DrawThread(acc , "小明");
        xiaoMing.start();

        Thread xiaoRed = new DrawThread(acc, "小红");
        xiaoRed.start();
    }
}

public class DrawThread extends Thread {
    private Account acc ; // 定义了一个账户类型的成员变量接收取款的账户对象！
    public DrawThread(Account acc , String name){
        super(name); // 为当前线程对象取名字
        this.acc = acc ;
    }
    @Override
    public void run() {
        // 小明/小红
        acc.drawMoney(10000);
    }
}

public class Account {
    private double money ; // 余额
    private String cardId ;
    public Account(){

    }
    public Account(double money, String cardId) {
        this.money = money;
        this.cardId = cardId;
    }
    // 小明、小红执行到此
    public synchronized void drawMoney(double money) {
        // 1.先拿到是谁来取钱：取当前线程对象的名称
        String name = Thread.currentThread().getName();
        // 2.判断余额是否足够
        if(this.money >= money){
            // 3.余额足够
            System.out.println(name+"来取钱，吐出："+money);
            // 4.更新余额
            this.money -= money;
            // 5.输出结果
            System.out.println(name+"来取钱"+money+"成功，取钱后剩余："+this.money);
        }else{
            // 6.余额不足
            System.out.println(name+"来取钱，余额不足，剩余"+this.money);
        }
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
}

方式三：lock锁

lock显示锁： java.util.concurrent.locks.Lock机制提供了比synchronized代码块synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大 Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock():加同步锁。
public void unlock():释放同步锁。

总结：

线程安全，性能差。
线程不安全性能好。假如开发中不会存在多线程安全问题，建议使用线程不安全的设计类。

public class ThreadSafe {
    public static void main(String[] args) {
        // a.创建一个账户对象。
        Account acc = new Account(10000,"ICBC-110"  );
        // b.定义一个线程类创建2个线程代表小明和小红
        Thread xiaoMing = new DrawThread(acc , "小明");
        xiaoMing.start();

        Thread xiaoRed = new DrawThread(acc, "小红");
        xiaoRed.start();
    }
}

public class DrawThread extends Thread {
    private Account acc ; // 定义了一个账户类型的成员变量接收取款的账户对象！
    public DrawThread(Account acc , String name){
        super(name); // 为当前线程对象取名字
        this.acc = acc ;
    }
    @Override
    public void run() {
        // 小明/小红
        acc.drawMoney(10000);
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 账户类
public class Account {
    private double money ; // 余额
    private String cardId ;
    // 创建一把锁对象:因为账户对象对于小明小红是唯一的，所以这里的锁对象对于小明小红也是唯一的
    private final Lock lock = new ReentrantLock();
    public Account(){

    }
    public Account(double money, String cardId) {
        this.money = money;
        this.cardId = cardId;
    }
    // 小明、小红执行到此
    public void drawMoney(double money) {
        // 1.先拿到是谁来取钱：取当前线程对象的名称
        String name = Thread.currentThread().getName();
        lock.lock(); // 上锁~!
        try{
            if(this.money >= money){
                // 3.余额足够
                System.out.println(name+"来取钱，吐出："+money);
                // 4.更新余额
                this.money -= money;
                // 5.输出结果
                System.out.println(name+"来取钱"+money+"成功，取钱后剩余："+this.money);
            }else{
                // 6.余额不足
                System.out.println(name+"来取钱，余额不足，剩余"+this.money);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock(); // 解锁~!
        }

    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
}