AI 助理
备案控制台
开发者社区 安全 文章 正文

Java基础 | 多线程

2022-10-17 87
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
语种识别，语种识别 100万字符
文档翻译，文档翻译 1千页
图片翻译，图片翻译 100张
简介： Java中的多线程

多线程

（一）实现多线程

1.进程

进程：是正在运行的程序

  • 是系统进行资源分配和调用的独立单位
  • 每一个进程都有它自己的内存空间和系统资源

2.线程

线程：是进程中的单个顺序控制流，是一条执行路径

  • 单线程：一个进程如果只有一条执行路径，则称为单线程程序
  • 多线程：一个进程如果有多条执行路径，则称为多线程程序

举例

  • 记事本程序（调整页面大小时不能同时修改文本中的内容）
  • 扫雷程序（玩的同时不影响计时）

3.多线程的第一种实现方式

方式1：继承Thread类

  • 定义一个类MyThread继承Thread类
  • 在MyThread类中重写run()方法
  • 创建MyThread类的对象
  • 启动线程

两个小问题：

  • 为什么要重写run()方法？

    ​ 因为run()是用来封装被线程执行的代码

  • run()方法和start()方法的区别？

    ​ run()：封装线程执行的代码，直接调用，相当于普通方法的调用

    ​ start()：启动线程；然后由JVM调用此线程的run()方法

代码演示：

定义Mythread类：

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
    //重写run的目的：将自定义代码存储在run方法，让线程运行。
}

创建测试类：

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        MyThread mt2 = new MyThread();
        mt.start();
        mt2.start();
    }
}

4.设置和获取线程名称

Thread类中设置和获取线程名称的方法

  • void setName(String name)：将此线程的名称更改为等于参数name
  • String getName()：返回次线程的名称
  • 通过构造方法也可以设置线程名称

如何获取main()方法所在的线程名称？

  • public static Thread currentThread()：返回对当前正在执行的线程对象的引用

代码演示：

定义MyThread类：

public class MyThread extends Thread {
    public MyThread() {}

    public MyThread(String name){//给出带参构造方法
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ": " + i);
        }
    }
    //重写run的目的：讲自定义代码存储在run方法，让线程运行。
}

定义测试类：

public class ThreadDemo {
    public static void main(String[] args) {
        //无参构造
        MyThread mt = new MyThread();
        MyThread mt2 = new MyThread();

        //给线程设置名称
        mt.setName("火车");
        mt2.setName("飞机");

        //带参构造
        MyThread mt3 = new MyThread("小汽车");
        MyThread mt4 = new MyThread("轮船");
        
        //启动线程
        mt.start();
        mt2.start();
        mt3.start();
        mt4.start();
        
        //获取main方法所在的线程名称
        System.out.println(Thread.currentThread().getName()); //main
    }
}

5.线程调度

线程有两种调度模型

  • 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
  • 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么随机会选择一个，优先级高的线程获取的CPU时间片相对多一些

java使用的是抢占式调度模型

假如计算机只有一个CPU，那么CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

Thread类中设置和获取线程优先级的方法

  • public final int getPriority()：返回此线程的优先级
  • public final void setPriority(int newPriority)：更改此线程的优先级

注意：即使设置了优先级，也不一定优先级大的也不一定优先，因为设置优先级的大小仅仅只是提高了抢占到CPU时间片的概率，只有多次运行或者次数比较多的时候才能看到想要的效果

代码演示：

public class ThreadDemo {
    public static void main(String[] args) {
        //无参构造
        MyThread mt = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();

        //给线程设置名称
        mt.setName("火车");
        mt2.setName("飞机");
        mt3.setName("小汽车");


        //获得此线程的优先级
        System.out.println(mt.getPriority());//5
        System.out.println(mt2.getPriority());//5
        System.out.println(mt3.getPriority());//5
        System.out.println(Thread.MAX_PRIORITY);//最大优先级为10  被final和static修饰的成员变量
        System.out.println(Thread.MIN_PRIORITY);//最小优先级为1
        System.out.println(Thread.NORM_PRIORITY);//默认的优先级为5
        //设置线程优先级
        mt.setPriority(10);
        mt2.setPriority(5);
        mt3.setPriority(1);

        //启动线程
        mt.start();
        mt2.start();
        mt3.start();

    }
}

5.线程控制

在这里插入图片描述

代码演示：

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ": " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();

        mt.setName("关羽");
        mt2.setName("张飞");
        mt3.setName("刘备");

        //启动线程
        mt.start();
        try {
            //void join()
            mt.join();//只有当这个线程结束时，其他线程才会继续执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mt2.start();
        mt3.start();

    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        MyThread mt2 = new MyThread();

        mt.setName("关羽");
        mt2.setName("张飞");

        //设置主线程
        Thread.currentThread().setName("刘备");

        //设置守护线程 void setDaemon(boolean on)
        mt.setDaemon(true);
        mt2.setDaemon(true);

        //启动线程
        mt.start();
        mt2.start(); //当主线程结束时，守护线程也会结束

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

6.线程的生命周期

在这里插入图片描述

7.多线程的第二种实现方式

实现Runnable接口

  • 定义一个MyRunnable类实现Runnable接口
  • 重写MyRunnable中的run()方法
  • 创建MyRunnable类的对象
  • 创建Thread类的对象，并把MyRunnable类的对象作为构造方法的参数
  • 启动线程

多线程的实现方案有两种：

  • 继承Thread类
  • 实现Runnable接口

相比继承Thread类，实现Runnable接口的好处

  • 避免了Java单继承的局限性
  • 适合多个相同程序的代码去处理同一个资源的情况，把线程和代码、数据有效分离，较好的体现了面向对象的设计思想

代码演示：

定义MyRunnable类

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++)
            //因为getName()是Thread类的特有方法，因为前面第一种方法是继承了Thread类才可以使用
            //此处想要使用getName()方法，就要先获取当前线程Thread.currentThread() 获取到了线程才可以使用其getName()方法
            System.out.println(Thread.currentThread().getName() + "： " + i);
    }
}

测试类：

public class RunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable mr = new MyRunnable();
        
        //创建Thread类的对象
        Thread t = new Thread(mr,"飞机");
        Thread t2 = new Thread(mr,"火车");

        //启动线程
        t.start();
        t2.start();
    }
}

（二）线程同步

1.案例（卖票）

定义卖票类（SellTicket）：

public class SellTicket implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {
        while(true){
            //下面代码会导致卖票出现两种问题 ：1.相同的票卖了多次 2.出现了负数的票
            if (tickets > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             
                System.out.println("第"+tickets+"张票被"+Thread.currentThread().getName()+"卖出");
                tickets--;
            } else {
                System.out.println(Thread.currentThread().getName()+"显示票已卖完");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

创建测试类：

public class SellTicketDemo {
    public static void main(String[] args) {
        //创建卖票类对象
        SellTicket st = new SellTicket();
        //创建线程对象
        Thread t1 = new Thread(st,"第1窗口");
        Thread t2 = new Thread(st,"第2窗口");
        Thread t3 = new Thread(st,"第3窗口");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

卖票出现了问题：

  • 相同的票卖了多次
  • 出现了负数的票

问题原因：

  • 线程执行的随机性导致的

2.卖票案例数据安全问题的解决

为什么出现问题？（这也是判断多线程程序是否会有数据安全问题的标准）

  • 是否是多线程环境
  • 是否有共享数据
  • 是否有多条语句操作共享数据

如何解决多线程安全问题？

  • 基本思想：让程序没有安全问题的环境

怎么实现？

  • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
  • Java提供了同步代码块的方式来解决

3.同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现

  • 格式：

    ​ synchronized(任意对象) {

    ​ 多条语句操作共享数据的代码

    }

  • synchronized(任意对象):就相当于给代码加锁了，任意对象就可以看成一把锁

改进定义的Sellticket类

public class SellTicket implements Runnable {
    private int tickets = 1000;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {//此处加上同一把锁，当线程进来先看是否持有锁，有则可以进去执行，只有当前一个线程执行完代码块之后，下一个线程才可以进来
                 //下面代码会导致卖票出现两种问题 ：1.相同的票卖了多次 2.出现了负数的票
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("第" + tickets + "张票被" + Thread.currentThread().getName() + "卖出");
                    tickets--;
                } else {
                    System.out.println(Thread.currentThread().getName() + "显示票已卖完");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

4.线程同步方法

代码演示：

public class SellTicket implements Runnable {
    private static int tickets = 100;
    private Object obj = new Object();
    private int index = 0;

    @Override
    public void run() {
        while (true) {
            if (index % 2 == 0) {
                synchronized (SellTicket.class) {//此处加上同一把锁，当线程进来先看是否持有锁，有则可以进去执行，只有当前一个线程执行完代码块之后，下一个线程才可以进来
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                        //下面两行代码会导致卖票出现两种问题 ：1.相同的票卖了多次 2.出现了负数的票
                        System.out.println("第" + tickets + "张票被" + Thread.currentThread().getName() + "卖出");
                        tickets--;
                    }
                }
            } else {
//                synchronized (obj) {//此处加上同一把锁，当线程进来先看是否持有锁，有则可以进去执行，只有当前一个线程执行完代码块之后，下一个线程才可以进来
//                    if (tickets > 0) {
//                        try {
//                            Thread.sleep(100);
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//
//                        //下面两行代码会导致卖票出现两种问题 ：1.相同的票卖了多次 2.出现了负数的票
//                        System.out.println("第" + tickets + "张票被" + Thread.currentThread().getName() + "卖出");
//                        tickets--;
//                    }
//                }
                sellTicket();
            }
            index++;
        }
    }

    private  static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //下面两行代码会导致卖票出现两种问题 ：1.相同的票卖了多次 2.出现了负数的票
            System.out.println("第" + tickets + "张票被" + Thread.currentThread().getName() + "卖出");
            tickets--;
        }

    }
}

5.线程安全的类

在这里插入图片描述

代码演示：

import java.util.*;

public class ThreadDemo2 {
    public static void main(String[] args) {
        StringBuffer sf = new StringBuffer();
        StringBuilder sb = new StringBuilder();
        
        Vector<String> v = new Vector<>();
        ArrayList<String> array = new ArrayList<>();
        
        Hashtable<String,String> ht = new Hashtable<>();
        HashMap<String,String> hm = new HashMap<>();
        
        //集合通常使用以下Collections工具类的方法来保证线程同步
        List<String> list = Collections.synchronizedList(new ArrayList<>());
    }
}

6.Lock锁

在这里插入图片描述

代码演示：

定义卖票类：（测试类省略参考以前案例）

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

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Lock lock = new ReentrantLock(); //创建Lock类对象
    @Override
    public void run() {
        while (true) {
            
            try {//以下代码可能会出错导致没有释放掉锁
                lock.lock();//在此处加锁
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在售卖第" + tickets + "张票");
                    tickets--;
                }
            } finally {//无论上述代码是否出错都释放锁
                lock.unlock();//在此处释放锁
            }
           
            
        }
    }
}

（三）生产者消费者

1.概述

在这里插入图片描述

在这里插入图片描述

2.生产者消费者案例

定义奶箱类（Box）:

public class Box {
    private int milk; //奶箱中奶的数量
    private boolean flag = false; //奶箱的状态 ，默认开始奶箱为空的

    public synchronized void put(int milk) {
        //当奶箱有奶，就等待消费
        if (flag) {
            try {
                wait(); //wait()方法需要在线程同步里使用 所以方法加synchronized
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //当奶箱没有奶，就生产
        this.milk = milk;
        System.out.println("生产了" + milk + "瓶奶");
        //生产完改变奶箱的状态
        flag = true;
        //唤醒其他线程
        notifyAll();

    }

    public synchronized void get() {
        //当奶箱没有奶，就等待生产
        if (!flag) {  //此时假设flag为false  只有if里面为true时才执行，所以加一个逻辑非！来执行代码块内容
            try {
                wait(); //wait()方法需要在线程同步里使用 所以方法加synchronized
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //当奶箱有奶，就消费
        System.out.println("用户拿到了第" + milk + "瓶奶");
        //消费完，改变奶箱的状态
        flag = false;

        //唤醒其他线程启动
        notifyAll();
    }
}

定义生产者类：

public class Producer implements Runnable {
    private Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            b.put(i);
        }
    }
}

定义消费者类：

public class Customer implements Runnable{
    private Box b;
    public Customer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while(true) {
            b.get();
        }
    }
}

定义测试类：

public class BoxDemo {
    public static void main(String[] args) {
        //创建奶箱对象 这是共享区域
        Box b = new Box();

        //创建生产者对象
        Producer p = new Producer(b);
        //创建消费者对象
        Customer c = new Customer(b);

        //创建两个线程对象
        Thread td1 = new Thread(p,"生产者");
        Thread td2 = new Thread(c,"消费者");

        //启动线程
        td1.start();
        td2.start();
    }
}
文章标签：
机器翻译
Java
安全
调度
关键词：
Java线程
Java多线程
java基础线程
Java基础
Java基础多线程
BoBooY
目录
相关文章
yuanzhengme
|
5天前
|
安全 Java 调度
Java编程时多线程操作单核服务器可以不加锁吗？
Java编程时多线程操作单核服务器可以不加锁吗？
yuanzhengme
17 2
1176112968452250
|
8天前
|
存储 缓存 Java
java线程内存模型底层实现原理
java线程内存模型底层实现原理
1176112968452250
28 2
java线程内存模型底层实现原理
请看我回答~
|
10天前
|
Java 开发者
Java中的多线程基础与应用
【9月更文挑战第22天】在Java的世界中，多线程是一块基石，它支撑着现代并发编程的大厦。本文将深入浅出地介绍Java中多线程的基本概念、创建方法以及常见的应用场景，帮助读者理解并掌握这一核心技术。
请看我回答~
18 5
杀死一只知更鸟debug
|
6天前
|
Java 调度
Java-Thread多线程的使用
这篇文章介绍了Java中Thread类多线程的创建、使用、生命周期、状态以及线程同步和死锁的概念和处理方法。
杀死一只知更鸟debug
9 0
Java-Thread多线程的使用
龙大吉
|
12天前
|
Java
领略Lock接口的风采，通过实战演练，让你迅速掌握这门高深武艺，成为Java多线程领域的武林盟主
领略Lock接口的风采，通过实战演练，让你迅速掌握这门高深武艺，成为Java多线程领域的武林盟主
龙大吉
22 7
游客qf4jmczx4xu2y
|
11天前
|
Java 程序员
Java中的多线程基础与实践
【9月更文挑战第21天】本文旨在引导读者深入理解Java多线程的核心概念，通过生动的比喻和实例，揭示线程创建、同步机制以及常见并发工具类的使用。文章将带领读者从理论到实践，逐步掌握如何在Java中高效地运用多线程技术。
游客qf4jmczx4xu2y
18 5
萝卜带泥
|
9天前
|
Java 调度 开发者
Java中的多线程编程：从基础到实践
本文旨在深入探讨Java多线程编程的核心概念和实际应用，通过浅显易懂的语言解释多线程的基本原理，并结合实例展示如何在Java中创建、控制和管理线程。我们将从简单的线程创建开始，逐步深入到线程同步、通信以及死锁问题的解决方案，最终通过具体的代码示例来加深理解。无论您是Java初学者还是希望提升多线程编程技能的开发者，本文都将为您提供有价值的见解和实用的技巧。
萝卜带泥
15 2
muxiaoxi
|
11天前
|
Java 数据处理
Java中的多线程编程：从基础到实践
本文旨在深入探讨Java中的多线程编程，涵盖其基本概念、创建方法、同步机制及实际应用。通过对多线程基础知识的介绍和具体示例的演示，希望帮助读者更好地理解和应用Java多线程编程，提高程序的效率和性能。
muxiaoxi
19 1
喜欢猪猪
|
4天前
|
Java 数据中心 微服务
Java高级知识：线程池隔离与信号量隔离的实战应用
在Java并发编程中，线程池隔离与信号量隔离是两种常用的资源隔离技术，它们在提高系统稳定性、防止系统过载方面发挥着重要作用。
喜欢猪猪
5 0
游客vsgxb64qlj7cg
|
6天前
|
Java 数据处理 调度
Java中的多线程编程：从基础到实践
本文深入探讨了Java中多线程编程的基本概念、实现方式及其在实际项目中的应用。首先，我们将了解什么是线程以及为何需要多线程编程。接着，文章将详细介绍如何在Java中创建和管理线程，包括继承Thread类、实现Runnable接口以及使用Executor框架等方法。此外，我们还将讨论线程同步和通信的问题，如互斥锁、信号量、条件变量等。最后，通过具体的示例展示了如何在实际项目中有效地利用多线程提高程序的性能和响应能力。
游客vsgxb64qlj7cg
12 0

热门文章

最新文章

  • 1
    iOS多线程开发系列之(三)Grand Central Dispatch(GCD)
  • 2
    .NET简谈组件程序设计之(初识.NET线程Thread)
  • 3
    Java 使用线程方式Thread和Runnable，以及Thread与Runnable的区别
  • 4
    Android Priority Job Queue (Job Manager)：后台线程任务结果传回前台（三）
  • 5
    分析SpinnerActivityTest中有关控件操作以及UI线程问题
  • 6
    浅谈一个线程通信代码的内存泄露及解决方案
  • 7
    SpringBoot线程池ThreadPoolExecutor极简教程
  • 8
    Python多线程编程之多线程加锁
  • 9
    踏破铁鞋无觅处，从AsyncTask学Android线程池
  • 10
    从Socket数据处理线程想到的普通Winform数据显示的应用
  • 1
    Java 文件处理完全指南：创建、读取、写入和删除文件详细解析
    467
  • 2
    Java的语法基础
    46
  • 3
    Java的面向对象设计
    39
  • 4
    java的类加载过程
    41
  • 5
    java的常见算法
    54
  • 6
    Java的IO技术和NIO技术
    68
  • 7
    JAVA字符串与其他类型数据的转换
    108
  • 8
    JAVA字符串的基本操作
    64
  • 9
    JAVA一维数组
    74
  • 10
    JAVA跳转控制语句
    60

    • 相关课程

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

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • 多IO线程优化版

    • 相关实验场景

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