Java多线程

Qi妙代码

于 2024-08-12 08:35:42 发布

阅读量519

点赞数 16

文章标签： java 开发语言 android

本文链接：https://blog.csdn.net/qq_36816794/article/details/141116559

版权

1. 进程和线程

1.1. 进程和线程

程序：一段静态代码，是应用程序执行的蓝本
进程：一种正在运行的程序，有自己的地址空间
- 动态性
- 并发性
- 独立性
并发和并行的区别
- 并行：多个CPU同时执行多个任务
- 并发：一个CPU（采用时间片）同时执行多个任务
线程
- 进程内部的一个执行单元，是程序中一个单一的顺序控制流程
- 线程又被称为轻量级进程
- 如果在一个进程中同时运行多个线程，用来完成不同的工作，则称为多线程
线程特点
- 轻量级进程
- 独立调度的基本单位
- 共享进程资源
- 可并发执行
线程和进程的区别

1.2. 线程定义和创建1: 继承Thread类

Thread类是Java提供的线程顶级类，继承Thread类可快速定义线程

public class TortoiseThread extends Thread {
    // 线程体：线程要完成的任务，要执行的代码
    @Override
    public void run() {
        while (true) {
            System.out.println("当前线程名称：" + this.getName() + "，当前线程的优先级别：" + this.getPriority());
        }
    }
}
public class Test {
    public static void main(String[] args) {
        // 创建一个线程
        TortoiseThread thread = new TortoiseThread();
        // 启动一个线程，进入就绪队列，等待获得CPU
        thread.start();
        while (true) {
            System.out.println("当前线程名称：" + Thread.currentThread().getName() + "，当前线程优先级：" + Thread.currentThread().getPriority());
        }
    }
}

run()线程体，线程要完成的任务
start()启动线程，线程进入就绪队列，等待获取CPU并执行

2. 线程的定义和创建

2.1. 线程定义和创建2: 实现Runnable接口

public class TortoiseRunnable implements Runnable{
    @Override
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + "    " + Thread.currentThread().getPriority());
        }
    }
}
public class Test1 {
    public static void main(String[] args) {
        // 创建线程对象
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName());
                }
            }
        };
        Thread thread1 = new Thread(runnable);
        thread1.start();
        Thread thread2 = new Thread(runnable);
        thread2.start();
        while (true) {
            System.out.println(Thread.currentThread().getName() + "  " + Thread.currentThread().getPriority());
        }
    }
}

两种方式的优缺点
1. 继承Thread类：
  - 缺点：Java单继承，无法继承其他类
  - 优点：代码稍微简单
2. 实现Runnable接口（实际开发中使用较多）
  - 缺点：代码略繁琐
  - 优点：还可以继承其他类，便于多个线程共享同一个资源
可以使用匿名内部类来创建线程对象
Thread的属性和方法
- MAX_PRIORITY：static int：线程可以具有的最高优先级
- MIN_PRIORITY：static int：线程可以具有的最低优先级
- NORM_PRIORITY：static int：分配给线程的默认优先级
- currentThread()：static Thread：返回对当前正在执行的线程对象的引用
- getName()：String：返回该线程的名称
- getPriority()：int：返回线程的优先级
- run()：void：如果该线程是使用独立的Runnable运行对象构造的，则调用该Runnable对象的run方法；否则，该方法不执行任何操作并返回
- setName(String name)：void：改变线程名称，使之与参数name相同
- setPriority(int newPriority)：void：更改线程的优先级
- start()：void：使该线程开始执行；java虚拟机调用该线程的run方法

2.2. 线程定义和创建3: 实现Callable接口

JDK1.5后推出了Callable接口定义线程

public class RandomCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        Thread.sleep(5000);
        return new Random().nextInt(10);
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<Integer> callable = new RandomCallable();
        FutureTask<Integer> task = new FutureTask<>(callable);
        new Thread(task).start();
        // 线程是否执行完毕，获得返回值
        System.out.println(task.isDone()); // false
        // 必须等线程执行完毕后，才能得到返回值，线程在此会阻塞
        Integer num = task.get();
        System.out.println(num); // 8
        System.out.println(task.isDone()); // true
    }
}

与Runnable相比，Callable功能更强大
- 方法名不同
- 可以有返回值，支持泛型的返回值
- 可以抛出检查异常
- 需要借助FutureTask，比如获取返回结果
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
- FutureTask是Future接口的唯一实现类
- FutureTask同时实现了Runnable、Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

2.3. 线程的生命周期

在这里插入图片描述

新生状态
- 用new关键字建立一个线程对象后，该线程对象就处于新生状态
- 处于新生状态的线程有自己的内存空间，通过调用start进入就绪状态
就绪状态
- 处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU
- 当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，称为cpu调度
运行状态
- 当运行状态的线程执行自己的run方法中代码，直到等待某资源而阻塞或完成任务死亡
- 如果在给定时间片内没执行结束，就会被系统给换下来回到等待执行状态
阻塞状态
- 处于运行状态的线程在某些情况下，如执行了sleep方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态
- 在阻塞状态的进程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续运行
死亡状态
- 死亡状态是线程生命周期中最后一个阶段。线程死亡原因有三个：正常运行的线程完成了他的全部工作、线程被强制性地终止，如通过执行stop方法来终止一个线程（不推荐使用）、线程抛出未捕获异常

3. 线程控制

理解了线程生命周期的基础上，可以使用java提供的线程控制命令对线程的生命周期进行干预

join()：阻塞指定线程等到另一个线程完成以后再继续执行
sleep()：使线程停止运行一段时间，让出CPU，将处于阻塞状态。
如调用了sleep方法后，没有其他等待执行的线程，此时当前线程不会马上恢复执行
实际开发中经常使用Thread.sleep()开模拟线程切换，暴露线程安全问题
yield()：让当前正在执行线程暂停，不是阻塞线程，而是将线程转入就绪状态
如果调用了yield方法之后，没有其他等待执行的线程，此时当前线程会马上恢复执行
setDaemon()：将指定的线程设置成后台线程
创建后台线程的线程结束时，后台线程也随之消亡
只能在线程启动之前把它设为后台线程
interrupt()：并没有直接中断线程，而是需要被中断线程自己处理
stop()：结束线程，不推荐使用

3.1. 使用join()阻塞当前线程

public class Test2 {
    public static void main(String[] args) {
        int i = 0;
        while (i <= 200) {
            if(i == 20) {
                TortoiseThread thread = new TortoiseThread();
                thread.setName("孙悟空");
                thread.start();
                try {
                    // 线程A正在执行，线程B进来，线程B执行完，A才会执行，A此间处于阻塞状态
                    thread.join();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(i + " " + Thread.currentThread().getName() + " " + Thread.currentThread().getPriority());
            i++;
        }
    }
}

3.2. 使用sleep()让线程休眠

public class TortoiseThread1 extends Thread{
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.getName() + " " + this.getPriority());
        }
    }
}
public class Test3 {
    public static void main(String[] args) {
        TortoiseThread1 thread = new TortoiseThread1();
        thread.start();
        while (true) {
            try {
                Thread.sleep(1);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getPriority());
        }
    }
}

3.3. 使用setDaemon()设置守护线程

public class Test4 {
    public static void main(String[] args) {
        TortoiseThread thread = new TortoiseThread();
        // 后台线程，守护线程，寄生线程
        thread.setDaemon(true);
        thread.start();
        int i = 0;
        while (i <= 200) {
            System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getPriority());
            i++;
        }
    }
}

3.4. 中断线程

public class TortoiseThread2 extends Thread {
    private int num = 100;
    public void run() {
        while (!isInterrupted()) {
            System.out.println(this.getName() + " " + this.getPriority());
        }
    }
}
public class Test5 {
    public static void main(String[] args) {
        TortoiseThread2 thread = new TortoiseThread2();
        thread.start();
        int i = 0;
        while (i <= 200) {
            System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getPriority());
            i++;
        }
        // thread.stop(); 不推荐，相当于直接关机
        thread.interrupt(); // 中断
    }
}

4. 线程同步

4.1. 问题的提出

应用场景：多个用户同时操作一个银行账户，每次取款400元，取款前先检查余额是否充足，如果不够，放弃取款
分析
- 使用多线程解决
- 开发一个取款线程类，每个用户对应一个线程对象
- 因为多个线程共享同一个银行账户，使用Runnable方式解决
思路
- 创建银行账户类Account
- 创建取款线程AccountRunnable
- 创建测试类TestAccount，让两个用户同时取款

// 银行账户
public class Account {
    private int balance = 600;
    // 取款
    public void withDraw(int money) {
        this.balance = this.balance - money;
    }
    // 查看余额
    public int getBalance() {
        return balance;
    }
}
public class AccountRunnable implements Runnable {
    private Account account = new Account();
    @Override
    public void run() {
        // 判断余额是否足够，够才取
        if(account.getBalance() >= 400) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 取款
            account.withDraw(400);
            System.out.println(Thread.currentThread().getName() + "取款成功，余额：" + account.getBalance());
        }else {
            System.out.println("余额不足，" + Thread.currentThread().getName() + "取款失败，余额：" + account.getBalance());
        }
    }
}
public class Test6 {
    public static void main(String[] args) {
        Runnable runnable = new AccountRunnable();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable, "thread");
        thread1.setName("孙悟空");
        thread1.start();
        thread2.start();
    }
}

分析：使用Thread.sleep()的目的在于模拟线程切换，在一个线程判断完余额后，不是立即取款，而是让出CPU，这样另一个线程获取CPU，并且进行余额的判断。
线程安全问题就这么产生了，如果保证线程安全，必须判断余额和取款的语句被一个线程执行完才能让另外一个线程执行

当多个线程访问同一个数据时，容易出现线程安全问题，需要让线程同步，保证数据安全
线程同步：当两个或两个以上线程访问同一资源时，需要某种方式来确保资源在某一时刻只被一个线程使用
线程同步的解决方案：
- 同步代码块：synchronized(obj) { }
- 同步方法：private synchronized void makeWithdrawal(int amt) { }
- Lock锁

4.2. 同步代码块

public class AccountRunnable1 implements Runnable {
    private Account account = new Account();
    @Override
    public void run() {
        // 锁
        synchronized (account) {
            if(account.getBalance() >= 400) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                account.withDraw(400);
                System.out.println(Thread.currentThread().getName() + "取款成功，余额：" + account.getBalance());
            }else {
                System.out.println("余额不足，" + Thread.currentThread().getName() + "取款失败，余额：" + account.getBalance());
            }
        }
    }
}

总结：synchronized锁（同步监听器）
1. 必须是引用数据类型，不能是基本数据类型
2. 在同步代码块中可以改变同步监视器对象的值，不能改变其引用
3. 尽量不要String和包装类Integer做同步监视器。如果使用了，只要保证代码块中不对其进行任何操作也可以
4. 一般使用共享资源做同步监视器即可
5. 也可以创建一个专门的同步监视器，没有任何业务含义
6. 建议使用final修饰同步监视器
总结：同步代码块的执行过程
1. 第一个线程来到同步代码块，发现同步监视器open状态，需要close，然后执行其中的代码
2. 第一个线程执行过程中，发生了线程切换（阻塞就绪），第一个线程就失去了CPU，但是没有开锁open
3. 第二个线程获取了CPU，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态
4. 第一个线程再次获取CPU，接着执行后续的代码；同步代码块执行完毕，释放锁open
5. 第二个线程也再次获取CPU，来到了同步代码块，发现同步监视器open状态，重复第一个线程的处理过程（加锁）
注意：同步代码块中也可以发生线程切换，但是后续的被执行线程也无法执行同步代码块（锁仍然close）
总结：线程同步的优缺点
- 优点：安全
- 缺点：效率低，可能出现死锁
总结：其他
1. 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块
2. 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他的同步监视器的代码块

4.3. 同步方法

public class AccountRunnable2 implements Runnable {
    private Account account = new Account();
    @Override
    public void run() {
        withDraw();
    }
    // 同步监视器都是this
    public synchronized void withDraw() {
        if(account.getBalance() >= 400) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.withDraw(400);
            System.out.println(Thread.currentThread().getName() + "取款成功，余额：" + account.getBalance());
        }else {
            System.out.println("余额不足，" + Thread.currentThread().getName() + "取款失败，余额：" + account.getBalance());
        }
    }
}

总结：关于同步方法
1. 不要将run()定义为同步方法
2. 同步方法的同步监视器是this
3. 同步代码块的效率要高于同步方法
  - 同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块
  - 同步方法是将线程锁在了方法的外部，而同步代码块锁将线程锁在了代码块的外部，但是却是方法的内部

4.3. Lock锁

JDK1.5中推出了新一代的线程同步方式：Lock锁

public class AccountRunnable3 implements Runnable {
    private Account account = new Account();
    // 买一把锁-可重用锁
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        try {
            // 上锁
            lock.lock();
            if (account.getBalance() >= 400) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                account.withDraw(400);
                System.out.println(Thread.currentThread().getName() + "取款成功，余额：" + account.getBalance());
            }else {
                System.out.println("余额不足，" + Thread.currentThread().getName() + "取款失败，余额：" + account.getBalance());
            }
        }finally {
            // 解锁
            lock.unlock();
        }
    }
}

Lock锁
- JDK1.5后新增功能，与采用synchronized相比，lock可提供多种锁方案，更灵活
- import java.util.concurrent.locks中Lock框架是锁定的一个抽象，它允许把锁定的实现作为java类，而不是作为语言的特性来实现。这就为Lock的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或锁定语义
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，他还提供了在激烈争用情况下更佳的性能
- 注意：如果同步代码有异常，要将unlock()写入finally语句块
Lock和synchronized的区别
- Lock是显式锁（手动开启和关闭锁），synchronized是隐式锁，遇到异常自动解锁
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- Lock锁可以对读不加锁，对写加锁，synchronized不可以
- Lock锁可以有多种获取锁的方式，可以从sleep的线程中抢到锁，synchronized不可以
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：Lock–同步代码块（已经进入了方法体，分配了相应资源）–同步方法（在方法体之外）

4.4. 线程同步练习

实现三种线程同步方式实现多个窗口买票，保证售票的安全性

4.4.1. 使用同步代码块实现多个窗口安全售票

public class TicketRunnable implements Runnable {
    private int ticketNum = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if(ticketNum <= 0) break;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖出第：" + ticketNum + "张票");
                ticketNum--;
            }
        }
    }
}

4.4.2. 使用同步方法实现多个窗口安全售票

public class TicketRunnable1 implements Runnable {
    private int ticketNum = 100;
    @Override
    public void run() {
        while (true) {
            sellOne();
            if(ticketNum == 0) break;
        }
    }
    public synchronized void sellOne() {
        if(ticketNum == 0) return;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "卖出第：" + ticketNum + "张票");
        ticketNum--;
    }
}

4.4.3. 使用Lock锁实现多个窗口安全售票

public class TicketRunnable2 implements Runnable {
    private int tickedNum = 100;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if(tickedNum == 0) break;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖出第：" + tickedNum + "张票");
                tickedNum--;
            }finally {
                lock.unlock();
            }
        }
    }
}

Qi妙代码

关注

16
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java多线程

Thread类是Java提供的线程顶级类，继承Thread类可快速定义线程// 线程体：线程要完成的任务，要执行的代码@OverrideSystem.out.println("当前线程名称：" + this.getName() + "，当前线程的优先级别：" + this.getPriority());// 创建一个线程// 启动一个线程，进入就绪队列，等待获得CPU。
复制链接

扫一扫