AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java多线程详解，一篇文章全部搞定(全文干货，万字“血书“，值得收藏)

2022-04-14 154
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java多线程详解，一篇文章全部搞定(全文干货，万字“血书“，值得收藏)

文章目录

一.线程的创建和使用

1.Thread类

  • Java虚拟机允许程序运行多个线程，它通过java.lang.Thread 类来体现。
  • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
  • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。
  • Thread类的构造器：
    • Thread():创建新的Thread对象
    • Thread(String threadName):创建线程并指定线程实例名
    • Thread(Runnable target):指定创建线程的目标对象，它实现了Runnable接口中的run方法
    • Thread(Runnable target, String name):创建新的Thread对象

2.创建多线程的四种方法

  • 继承Thread类的方式
  • 实现Runnable接口的方式
2.1 继承Thread类的方式

步骤为以下4步骤：

  1. 创建一个继承于Thread类的子类
  2. 该子类重写Thread父类的run() 方法，将线程执行的操作声明在run()中
  3. 创建该子类的对象
  4. 通过该子类对象调用start()

代码示例：

/**
 * @Author: YuShiwen
 * @Date: 2020/11/23 1:53 PM
 * @Version: 1.0
 */

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
    

    //2. 该子类重写Thread父类的run() 方法，将线程执行的操作声明在run()中
    // 这里我以输出100以内的质数为例
    @Override
    public void run() {
    
        label:for (int i = 2; i < 100; i++) {
    
            for(int j = 2; j < Math.sqrt(i);j++){
    
                if(i % j == 0){
    
                    continue label;
                }
            }
            System.out.println(Thread.currentThread().getName()+":质数"+i);
        }
    }
}

public class ThreadTestByInherit {
    

    public static void main(String[] args) {
    
        //3. 创建该子类的对象
        MyThread myThread = new MyThread();

        //4. 通过该子类对象调用start()
        myThread.start();

        //如果直接调用run(),是main线程，没有达到多线程的目的
        //myThread.run();

        //主线程输出
        System.out.println(Thread.currentThread().getName()+"：我是主线程");


    }
}

输出结果：

main：我是主线程
Thread-0:质数2
Thread-0:质数3
Thread-0:质数4
Thread-0:质数5
Thread-0:质数7
Thread-0:质数9
Thread-0:质数11
Thread-0:质数13
Thread-0:质数17
Thread-0:质数19
Thread-0:质数23
Thread-0:质数25
Thread-0:质数29
Thread-0:质数31
Thread-0:质数37
Thread-0:质数41
Thread-0:质数43
Thread-0:质数47
Thread-0:质数49
Thread-0:质数53
Thread-0:质数59
Thread-0:质数61
Thread-0:质数67
Thread-0:质数71
Thread-0:质数73
Thread-0:质数79
Thread-0:质数83
Thread-0:质数89
Thread-0:质数97

Process finished with exit code 0

注意点：

如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。想要启动多线程，必须调用start方法。一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上 的异常“IllegalThreadStateException”。
2.2 实现Runnable接口

步骤为以下5个步骤：

创建一个实现了Runnable接口的类实现类去实现Runnable中的抽象方法：run()创建实现类的对象将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象通过Thread类的对象调用start()

代码示例：

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
      
    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
      
        label:for (int i = 2; i < 100; i++) {
      
            for(int j = 2; j < Math.sqrt(i);j++){
      
                if(i % j == 0){
      
                    continue label;
                }
            }
            System.out.println(Thread.currentThread().getName()+":质数"+i);
        }
    }
}

public class ThreadTestByRunnable {
      
    public static void main(String[] args) {
      
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(mThread);
        //5. 通过Thread类的对象调用start()
        thread.start();
    }
}

输出结果：

Thread-0:质数2
Thread-0:质数3
Thread-0:质数4
Thread-0:质数5
Thread-0:质数7
Thread-0:质数9
Thread-0:质数11
Thread-0:质数13
Thread-0:质数17
Thread-0:质数19
Thread-0:质数23
Thread-0:质数25
Thread-0:质数29
Thread-0:质数31
Thread-0:质数37
Thread-0:质数41
Thread-0:质数43
Thread-0:质数47
Thread-0:质数49
Thread-0:质数53
Thread-0:质数59
Thread-0:质数61
Thread-0:质数67
Thread-0:质数71
Thread-0:质数73
Thread-0:质数79
Thread-0:质数83
Thread-0:质数89
Thread-0:质数97

Process finished with exit code 0

上述两种方式的比较

继承Thread：线程代码存放在Thread子类run方法中。实现Runnable：线程代码存放在接口实现类的run方法中。两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。在开发中，优先选择实现Runnable接口的方式 因为实现的方式没有类的单继承性的局限性多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
2.3 实现Callable接口(JDK 5.0新增)
与使用Runnable相比， Callable功能更强大些 相比run()方法，可以有返回值方法可以抛出异常支持泛型的返回值需要借助FutureTask类，比如获取返回结果Future接口 可以对具体Runnable、Callable任务的执行结果进行取消、查询是 否完成、获取结果等。FutrueTask是Futrue接口的唯一的实现类FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值 
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
        
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
        
            if(i % 2 == 0){
        
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
        
    public static void main(String[] args) {
        
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
        
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
        
            e.printStackTrace();
        } catch (ExecutionException e) {
        
            e.printStackTrace();
        }
    }

}

输出结果：

2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100 总和为：2550 Process finished with exit code 0
2.4 使用线程池

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

提高响应速度（减少了创建新线程的时间）降低资源消耗（重复利用线程池中线程，不需要每次都创建）便于线程管理 corePoolSize：核心池的大小maximumPoolSize：最大线程数keepAliveTime：线程没有任务时最多保持多长时间后会终止

代码示例：

class NumberThread implements Runnable{
           @Override public void run() {
           for(int i = 0;i <= 100;i++){
           if(i % 2 == 0){
           System.out.println(Thread.currentThread().getName() + ": " + i); } } } } class NumberThread1 implements Runnable{
           @Override public void run() {
           for(int i = 0;i <= 100;i++){
           if(i % 2 != 0){
           System.out.println(Thread.currentThread().getName() + ": " + i); } } } } public class ThreadPoolTest {
           public static void main(String[] args) {
           //1. 提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; //设置线程池的属性 // System.out.println(service.getClass()); // service1.setCorePoolSize(15); // service1.setKeepAliveTime(); //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象 service.execute(new NumberThread());//适合适用于Runnable service.execute(new NumberThread1());//适合适用于Runnable // service.submit(Callable callable);//适合使用于Callable //3.关闭连接池 service.shutdown(); } }

输出结果：

pool-1-thread-1: 0 pool-1-thread-1: 2 pool-1-thread-1: 4 pool-1-thread-1: 6 pool-1-thread-1: 8 pool-1-thread-1: 10 pool-1-thread-1: 12 pool-1-thread-1: 14 pool-1-thread-1: 16 pool-1-thread-1: 18 pool-1-thread-1: 20 pool-1-thread-1: 22 pool-1-thread-1: 24 pool-1-thread-1: 26 pool-1-thread-1: 28 pool-1-thread-1: 30 pool-1-thread-1: 32 pool-1-thread-1: 34 pool-1-thread-1: 36 pool-1-thread-1: 38 pool-1-thread-1: 40 pool-1-thread-1: 42 pool-1-thread-1: 44 pool-1-thread-1: 46 pool-1-thread-1: 48 pool-1-thread-1: 50 pool-1-thread-1: 52 pool-1-thread-1: 54 pool-1-thread-1: 56 pool-1-thread-1: 58 pool-1-thread-1: 60 pool-1-thread-1: 62 pool-1-thread-1: 64 pool-1-thread-1: 66 pool-1-thread-1: 68 pool-1-thread-1: 70 pool-1-thread-1: 72 pool-1-thread-1: 74 pool-1-thread-2: 1 pool-1-thread-2: 3 pool-1-thread-2: 5 pool-1-thread-2: 7 pool-1-thread-2: 9 pool-1-thread-2: 11 pool-1-thread-2: 13 pool-1-thread-2: 15 pool-1-thread-2: 17 pool-1-thread-2: 19 pool-1-thread-2: 21 pool-1-thread-2: 23 pool-1-thread-2: 25 pool-1-thread-2: 27 pool-1-thread-2: 29 pool-1-thread-2: 31 pool-1-thread-2: 33 pool-1-thread-2: 35 pool-1-thread-2: 37 pool-1-thread-2: 39 pool-1-thread-2: 41 pool-1-thread-2: 43 pool-1-thread-2: 45 pool-1-thread-2: 47 pool-1-thread-2: 49 pool-1-thread-2: 51 pool-1-thread-2: 53 pool-1-thread-2: 55 pool-1-thread-2: 57 pool-1-thread-2: 59 pool-1-thread-2: 61 pool-1-thread-2: 63 pool-1-thread-2: 65 pool-1-thread-2: 67 pool-1-thread-2: 69 pool-1-thread-2: 71 pool-1-thread-2: 73 pool-1-thread-2: 75 pool-1-thread-2: 77 pool-1-thread-2: 79 pool-1-thread-2: 81 pool-1-thread-2: 83 pool-1-thread-2: 85 pool-1-thread-2: 87 pool-1-thread-2: 89 pool-1-thread-2: 91 pool-1-thread-2: 93 pool-1-thread-2: 95 pool-1-thread-2: 97 pool-1-thread-2: 99 pool-1-thread-1: 76 pool-1-thread-1: 78 pool-1-thread-1: 80 pool-1-thread-1: 82 pool-1-thread-1: 84 pool-1-thread-1: 86 pool-1-thread-1: 88 pool-1-thread-1: 90 pool-1-thread-1: 92 pool-1-thread-1: 94 pool-1-thread-1: 96 pool-1-thread-1: 98 pool-1-thread-1: 100 Process finished with exit code 0

二.Thread类的相关方法

start():启动当前线程；调用当前线程的run()方法run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中currentThread():静态方法，返回执行当前代码的线程getName():获取当前线程的名字setName():设置当前线程的名字yield():暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若没有，继续执行当前线程。join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。stop():已过时。当执行此方法时，强制结束当前线程，不推荐使用。sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。isAlive():判断当前线程是否存活

代码示例：

class MyThreadClass extends Thread{
             @Override public void run() {
             label:for (int i = 2; i < 100; i++) {
             for(int j = 2; j < Math.sqrt(i);j++){
             if(i % j == 0){
             continue label; } } System.out.println(Thread.currentThread().getName()+":质数"+i); } } public MyThreadClass() {
             super(); } public MyThreadClass(String name) {
             super(name); } } public class ThreadMethodTest{
             public static void main(String[] args) {
             MyThreadClass thread0 = new MyThreadClass(); MyThreadClass thread1 = new MyThreadClass("线程二"); //getName():获取当前线程的名字 System.out.println(thread0.getName()); System.out.println(thread1.getName()); //setName():设置当前线程的名字 thread0.setName("线程一"); System.out.println(); System.out.println(thread0.getName()); System.out.println(thread1.getName()); //currentThread():静态方法，返回执行当前代码的线程 System.out.println(Thread.currentThread().getName()); //start():启动当前线程；调用当前线程的run()方法 thread0.start(); thread1.start(); //join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。 try {
             thread0.join(); thread1.join(); } catch (InterruptedException e) {
             e.printStackTrace(); } //直接调用run方法，此时是主线程直接调用的 thread0.run(); //yield():暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若没有，继续执行当前线程。 Thread.yield(); //sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。 //这里让主线程阻塞3秒 try {
             Thread.sleep(3000); } catch (InterruptedException e) {
             e.printStackTrace(); } //isAlive():判断当前线程是否存活 System.out.println(thread0.isAlive()); System.out.println(thread1.isAlive()); } }

输出结果：

Thread-0 线程二 线程一 线程二 main 线程二:质数2 线程二:质数3 线程二:质数4 线程二:质数5 线程二:质数7 线程一:质数2 线程一:质数3 线程一:质数4 线程一:质数5 线程一:质数7 线程一:质数9 线程一:质数11 线程一:质数13 线程二:质数9 线程二:质数11 线程二:质数13 线程二:质数17 线程二:质数19 线程二:质数23 线程二:质数25 线程二:质数29 线程二:质数31 线程二:质数37 线程二:质数41 线程二:质数43 线程一:质数17 线程二:质数47 线程二:质数49 线程二:质数53 线程二:质数59 线程二:质数61 线程二:质数67 线程二:质数71 线程二:质数73 线程二:质数79 线程二:质数83 线程二:质数89 线程二:质数97 线程一:质数19 线程一:质数23 线程一:质数25 线程一:质数29 线程一:质数31 线程一:质数37 线程一:质数41 线程一:质数43 线程一:质数47 线程一:质数49 线程一:质数53 线程一:质数59 线程一:质数61 线程一:质数67 线程一:质数71 线程一:质数73 线程一:质数79 线程一:质数83 线程一:质数89 线程一:质数97 main:质数2 main:质数3 main:质数4 main:质数5 main:质数7 main:质数9 main:质数11 main:质数13 main:质数17 main:质数19 main:质数23 main:质数25 main:质数29 main:质数31 main:质数37 main:质数41 main:质数43 main:质数47 main:质数49 main:质数53 main:质数59 main:质数61 main:质数67 main:质数71 main:质数73 main:质数79 main:质数83 main:质数89 main:质数97 false false Process finished with exit code 0

三.线程的调度、优先级、分类和生命周期

1.线程的调度

调度策略：时间片轮转策略和抢占式策略Java的调度方法： 同优先级线程组成先进先出队列(先到先服务)，使用时间片轮转策略对高优先级，使用优先调度的抢占式策略

2.线程的优先级

常量表示的优先级：MAX_PRIORITY:10、MIN _PRIORITY:1、NORM_PRIORITY:5setPriority(int newPriority) :改变线程的优先级getPriority() :返回线程优先值线程创建时继承父线程的优先级低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

3.线程的分类

Java中的线程分为两类:一种是守护线程，一种是用户线程。守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。Java垃圾回收就是一个典型的守护线程。若JVM中都是守护线程，当前JVM将退出。

截图示例：在上述二.Thread类的相关方法的代码示例中加上如下代码段：

在这里插入图片描述
输出结果：把用户线程全部改为了守护线程，JVM中都是守护线程，当前JVM将退出。

在这里插入图片描述

4.线程的生命周期

Java线程它的一个完整的生命周期中通常要经历如下的五种状态:

新建: 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态就绪:处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能阻塞:在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中 止自己的执行，进入阻塞状态死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

在这里插入图片描述

四.线程的同步

1.同步代码块

synchronized(同步监视器){
//需要被同步的代码
}

需要被同步的代码不能包含代码多了，也不能包含代码少了。操作共享数据的代码，即为需要被同步的代码。共享数据：多个线程共同操作的变量。同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。多个线程必须要共用同一把锁。在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
1.1同步代码块解决继承Thread类方式的线程安全问题

代码示例：

/** * @Author: YuShiwen * @Date: 2020/11/24 2:42 PM * @Version: 1.0 */ class Seat extends Thread{
               private static int position = 100; private static Object obj = new Object(); @Override public void run() {
               while(true){
               synchronized (obj) {
              //或者synchronized (Seat.class)，只需要保证同步监视器相同即可 if (position > 0) {
               try {
               Thread.sleep(200); } catch (InterruptedException e) {
               e.printStackTrace(); } System.out.println("从"+this.getName() + "得到座位，座位号为：" + position); --position; } else {
               break; } } } } } public class SeatTest {
               public static void main(String[] args) {
               Seat seat0 = new Seat(); Seat seat1 = new Seat(); Seat seat2 = new Seat(); seat0.setName("渠道一"); seat1.setName("渠道二"); seat2.setName("渠道三"); seat0.start(); seat1.start(); seat2.start(); } }

输出结果：

从渠道一得到座位，座位号为：100 从渠道一得到座位，座位号为：99 从渠道三得到座位，座位号为：98 从渠道三得到座位，座位号为：97 从渠道三得到座位，座位号为：96 从渠道三得到座位，座位号为：95 从渠道三得到座位，座位号为：94 从渠道三得到座位，座位号为：93 从渠道三得到座位，座位号为：92 从渠道三得到座位，座位号为：91 从渠道三得到座位，座位号为：90 从渠道三得到座位，座位号为：89 从渠道三得到座位，座位号为：88 从渠道三得到座位，座位号为：87 从渠道三得到座位，座位号为：86 从渠道三得到座位，座位号为：85 从渠道三得到座位，座位号为：84 从渠道三得到座位，座位号为：83 从渠道二得到座位，座位号为：82 从渠道二得到座位，座位号为：81 从渠道二得到座位，座位号为：80 从渠道二得到座位，座位号为：79 从渠道二得到座位，座位号为：78 从渠道二得到座位，座位号为：77 从渠道二得到座位，座位号为：76 从渠道二得到座位，座位号为：75 从渠道二得到座位，座位号为：74 从渠道二得到座位，座位号为：73 从渠道二得到座位，座位号为：72 从渠道二得到座位，座位号为：71 从渠道二得到座位，座位号为：70 从渠道二得到座位，座位号为：69 从渠道二得到座位，座位号为：68 从渠道二得到座位，座位号为：67 从渠道二得到座位，座位号为：66 从渠道二得到座位，座位号为：65 从渠道二得到座位，座位号为：64 从渠道二得到座位，座位号为：63 从渠道二得到座位，座位号为：62 从渠道三得到座位，座位号为：61 从渠道三得到座位，座位号为：60 从渠道三得到座位，座位号为：59 从渠道三得到座位，座位号为：58 从渠道三得到座位，座位号为：57 从渠道三得到座位，座位号为：56 从渠道三得到座位，座位号为：55 从渠道三得到座位，座位号为：54 从渠道三得到座位，座位号为：53 从渠道三得到座位，座位号为：52 从渠道三得到座位，座位号为：51 从渠道三得到座位，座位号为：50 从渠道三得到座位，座位号为：49 从渠道三得到座位，座位号为：48 从渠道三得到座位，座位号为：47 从渠道三得到座位，座位号为：46 从渠道三得到座位，座位号为：45 从渠道三得到座位，座位号为：44 从渠道三得到座位，座位号为：43 从渠道三得到座位，座位号为：42 从渠道三得到座位，座位号为：41 从渠道三得到座位，座位号为：40 从渠道三得到座位，座位号为：39 从渠道三得到座位，座位号为：38 从渠道三得到座位，座位号为：37 从渠道三得到座位，座位号为：36 从渠道三得到座位，座位号为：35 从渠道三得到座位，座位号为：34 从渠道三得到座位，座位号为：33 从渠道三得到座位，座位号为：32 从渠道三得到座位，座位号为：31 从渠道三得到座位，座位号为：30 从渠道一得到座位，座位号为：29 从渠道一得到座位，座位号为：28 从渠道一得到座位，座位号为：27 从渠道一得到座位，座位号为：26 从渠道一得到座位，座位号为：25 从渠道三得到座位，座位号为：24 从渠道三得到座位，座位号为：23 从渠道三得到座位，座位号为：22 从渠道三得到座位，座位号为：21 从渠道三得到座位，座位号为：20 从渠道三得到座位，座位号为：19 从渠道三得到座位，座位号为：18 从渠道三得到座位，座位号为：17 从渠道三得到座位，座位号为：16 从渠道三得到座位，座位号为：15 从渠道三得到座位，座位号为：14 从渠道三得到座位，座位号为：13 从渠道三得到座位，座位号为：12 从渠道三得到座位，座位号为：11 从渠道三得到座位，座位号为：10 从渠道三得到座位，座位号为：9 从渠道三得到座位，座位号为：8 从渠道二得到座位，座位号为：7 从渠道二得到座位，座位号为：6 从渠道二得到座位，座位号为：5 从渠道二得到座位，座位号为：4 从渠道二得到座位，座位号为：3 从渠道三得到座位，座位号为：2 从渠道三得到座位，座位号为：1 Process finished with exit code 0
1.2同步代码块解决实现Runnable接口方式的线程安全问题
class Seat1 implements Runnable{
                 private int position = 100; @Override public void run() {
                 while(true){
                 synchronized (this) {
                 if (position > 0) {
                 try {
                 Thread.sleep(200); } catch (InterruptedException e) {
                 e.printStackTrace(); } System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position); --position; } else {
                 break; } } } } } public class SeatTest1 {
                 public static void main(String[] args) {
                 Seat1 seat1 = new Seat1(); Thread thread0 = new Thread(seat1); Thread thread1 = new Thread(seat1); Thread thread2 = new Thread(seat1); thread0.setName("渠道一"); thread1.setName("渠道二"); thread2.setName("渠道三"); thread0.start(); thread1.start(); thread2.start(); } }

输出结果：与上述结果差不多，这里为节省篇幅省略。

2.同步方法

synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如:
public synchronized void show (String name){ …
}

2.1使用同步方法处理继承Thread类方式中的线程安全问题
class Seat2 extends Thread{
                  private static int position = 100; @Override public void run() {
                  while (true){
                  getPosition(); } } //默认同步监视器：Seat2.class private static synchronized void getPosition(){
                  if(position > 0){
                  try {
                  Thread.sleep(200); } catch (InterruptedException e) {
                  e.printStackTrace(); } System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position); --position; } } } public class SeatTest2 {
                  public static void main(String[] args) {
                  Seat2 seat0 = new Seat2(); Seat2 seat1 = new Seat2(); Seat2 seat2 = new Seat2(); seat0.setName("渠道一"); seat1.setName("渠道二"); seat2.setName("渠道三"); seat0.start(); seat1.start(); seat2.start(); } }

输出结果：与上述结果差不多，这里为节省篇幅省略。

2.2使用同步方法解决实现Runnable接口的线程安全问题
在这里插入代码片class Seat3 implements Runnable{
                   private int position = 100; @Override public void run() {
                   while (true){
                   getPosition(); } } //默认同步监视器：this private synchronized void getPosition(){
                   if(position > 0){
                   try {
                   Thread.sleep(200); } catch (InterruptedException e) {
                   e.printStackTrace(); } System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position); --position; } } } public class SeatTest3 {
                   public static void main(String[] args) {
                   Seat3 seat3 = new Seat3(); Thread thread0 = new Thread(seat3); Thread thread1 = new Thread(seat3); Thread thread2 = new Thread(seat3); thread0.setName("渠道一"); thread1.setName("渠道二"); thread2.setName("渠道三"); thread0.start(); thread1.start(); thread2.start(); } }

输出结果：与上述结果差不多，这里为节省篇幅省略。

3.Lock（锁）

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

ps:如果同步代码有异常，要将unlock()写入finally语句块

代码示例：

class Seat implements Runnable{
                    private int position = 100; //1.实例化ReentrantLock private ReentrantLock lock = new ReentrantLock(); @Override public void run() {
                    while(true){
                    try{
                    //2.调用锁定方法lock() lock.lock(); if(position >0){
                    try {
                    Thread.sleep(200); } catch (InterruptedException e) {
                    e.printStackTrace(); } System.out.println("从"+Thread.currentThread().getName()+"得到座位，座位号为：" + position); --position; }else {
                    break; } }finally {
                    //3.调用解锁方法：unlock() lock.unlock(); } } } } public class LockTest {
                    public static void main(String[] args) {
                    Seat seat = new Seat(); Thread thread0 = new Thread(seat); Thread thread1 = new Thread(seat); Thread thread2 = new Thread(seat); thread0.setName("渠道一"); thread1.setName("渠道二"); thread2.setName("渠道三"); thread0.start(); thread1.start(); thread2.start(); } }

4.synchronized 与 Lock 的对比

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

5.释放锁和不会释放锁的操作

释放锁的操作

当前线程的同步方法、同步代码块执行结束。当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、 该方法的继续执行。当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
不会释放锁的操作线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程 挂起，该线程不会释放锁(同步监视器)。应尽量避免使用suspend()和resume()来控制线程

五.线程的通信

wait() 与 notify() 和 notifyAll() wait():令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待notifyAll ():唤醒正在排队等待资源的所有线程结束等待.这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常。因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁， 因此这三个方法只能在Object类中声明。

线程通信的应用：经典例题：生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

class Clerk{
                     private int productCount = 0; //生产产品 public synchronized void produceProduct() {
                     if(productCount < 20){
                     productCount++; System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品"); notify(); }else{
                     //等待 try {
                     wait(); } catch (InterruptedException e) {
                     e.printStackTrace(); } } } //消费产品 public synchronized void consumeProduct() {
                     if(productCount > 0){
                     System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品"); productCount--; notify(); }else{
                     //等待 try {
                     wait(); } catch (InterruptedException e) {
                     e.printStackTrace(); } } } } class Producer extends Thread{
                    //生产者 private Clerk clerk; public Producer(Clerk clerk) {
                     this.clerk = clerk; } @Override public void run() {
                     System.out.println(getName() + ":开始生产产品....."); while(true){
                     try {
                     Thread.sleep(10); } catch (InterruptedException e) {
                     e.printStackTrace(); } clerk.produceProduct(); } } } class Consumer extends Thread{
                    //消费者 private Clerk clerk; public Consumer(Clerk clerk) {
                     this.clerk = clerk; } @Override public void run() {
                     System.out.println(getName() + ":开始消费产品....."); while(true){
                     try {
                     Thread.sleep(20); } catch (InterruptedException e) {
                     e.printStackTrace(); } clerk.consumeProduct(); } } } public class ProductTest {
                     public static void main(String[] args) {
                     Clerk clerk = new Clerk(); Producer p1 = new Producer(clerk); p1.setName("生产者1"); Consumer c1 = new Consumer(clerk); c1.setName("消费者1"); Consumer c2 = new Consumer(clerk); c2.setName("消费者2"); p1.start(); c1.start(); c2.start(); } }
文章标签：
Java
安全
调度
关键词：
Java线程
Java多线程
Java文章
Java线程文章
Java多线程文章
YuShiwen
目录
相关文章
众所周知
|
6天前
|
安全 Java 开发者
深入解读JAVA多线程：wait()、notify()、notifyAll()的奥秘
在Java多线程编程中，`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中，每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践，帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法，确保线程安全和高效的通信。
众所周知
25 9
叫个什么名字
|
9天前
|
存储 安全 Java
Java多线程编程的艺术：从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式，旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战，随后详细介绍了Java中创建和管理线程的两种主要方式：继承Thread类与实现Runnable接口。通过实例代码，本文展示了如何正确启动、运行及同步线程，以及如何处理线程间的通信与协作问题。最后，文章总结了多线程编程的最佳实践，为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
叫个什么名字
45 5
ShaFaChuang-36210
|
6天前
|
监控 安全 Java
Java中的多线程编程：从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式，本文将以一个简短的代码示例作为开篇，直接展示多线程的魅力，随后再详细解析其背后的原理与实现方式，旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例：创建两个线程，分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
ShaFaChuang-36210
20 1
众所周知
|
9天前
|
Java
JAVA多线程通信：为何wait()与notify()如此重要？
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式，使线程在条件不满足时进入休眠状态，并在条件满足时被唤醒，从而确保数据一致性和同步。相比其他通信方式，如忙等待，这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
众所周知
24 3
2G冲浪词条
|
8天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全，提高了并发性能。
2G冲浪词条
21 1
Skyund
|
9天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程，是系统运行的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 线程 线程，与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间做切换工作时，负担要比
Skyund
20 1
东方睿赢
|
3月前
|
存储 监控 Java
Java多线程优化：提高线程池性能的技巧与实践
Java多线程优化：提高线程池性能的技巧与实践
东方睿赢
115 1
碳基肥宅
|
6月前
|
设计模式 监控 Java
Java多线程基础-11：工厂模式及代码案例之线程池（一）
本文介绍了Java并发框架中的线程池工具，特别是`java.util.concurrent`包中的`Executors`和`ThreadPoolExecutor`类。线程池通过预先创建并管理一组线程，可以提高多线程任务的效率和响应速度，减少线程创建和销毁的开销。
碳基肥宅
197 2
Hacynn
|
6月前
|
Java 数据库
【Java多线程】对线程池的理解并模拟实现线程池
【Java多线程】对线程池的理解并模拟实现线程池
Hacynn
59 1
yinying293
|
3月前
|
安全 算法 Java
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（下）
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）
yinying293
77 6

热门文章

最新文章

  • 1
    Java 生成 UUID
  • 2
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 3
    【Java用法】使用Java导出word文档的解决方案（适用于从服务器上下载到本地电脑）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    JDK6笔记（5）----JDBC4
  • 6
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 7
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 8
    （十三）java类的继承
  • 9
    Java基础之004-面向对象
  • 10
    java 定时调用 bat
  • 1
    Dubbo03【管理控制台和监控中心搭建】，Java开发实用必备的几款插件
    56
  • 2
    Java中int[]与Integer[]相互转化的方法，java基础知识面试重点总结
    35
  • 3
    Java 并发编程中的锁优化策略
    34
  • 4
    Java一分钟之-设计模式：装饰器模式与代理模式
    63
  • 5
    《手把手教你》系列技巧篇（四十六）-java+ selenium自动化测试-web页面定位toast-下篇（详解教程）
    63
  • 6
    刷题两个月，从入门到字节跳动offer丨GitHub标星16k+，美团Java面试题
    65
  • 7
    《MySQL 入门教程》第 05 篇 账户和权限，Java高并发编程详解深入理解pdf
    53
  • 8
    Java的前景如何，好不好自学？，万字Java技术类校招面试题汇总
    54
  • 9
    es集群安装，邮储银行java面试
    79
  • 10
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    98

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云OSS设置跨域访问