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

Java基础 | 多线程

2022-10-17 80
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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
目录
相关文章
米诺斯
|
15小时前
|
Java
java线程之用户线程与守护线程
java线程之用户线程与守护线程
米诺斯
6 1
java线程之用户线程与守护线程
龙大吉
|
1天前
|
Java
Java中的`synchronized`关键字是一个用于并发控制的关键字，它提供了一种简单的加锁机制来确保多线程环境下的数据一致性。
【6月更文挑战第24天】Java的`synchronized`关键字确保多线程数据一致性，通过锁定代码块或方法防止并发冲突。同步方法整个方法体为临界区，同步代码块则锁定特定对象。示例展示了如何在`Counter`类中使用`synchronized`保证原子操作和可见性，同时指出过度使用可能影响性能。
龙大吉
10 4
米诺斯
|
15小时前
|
安全 Java
java线程之List集合并发安全问题及解决方案
java线程之List集合并发安全问题及解决方案
米诺斯
6 1
米诺斯
|
15小时前
|
Java
java线程之定制化通信(多轮顺序打印问题)
java线程之定制化通信(多轮顺序打印问题)
米诺斯
6 1
东方睿赢
|
1天前
|
存储 Java C++
Java虚拟机(JVM)管理内存划分为多个区域：程序计数器记录线程执行位置；虚拟机栈存储线程私有数据
Java虚拟机(JVM)管理内存划分为多个区域：程序计数器记录线程执行位置；虚拟机栈存储线程私有数据，如局部变量和操作数；本地方法栈支持native方法；堆存放所有线程的对象实例，由垃圾回收管理；方法区（在Java 8后变为元空间）存储类信息和常量；运行时常量池是方法区一部分，保存符号引用和常量；直接内存非JVM规范定义，手动管理，通过Buffer类使用。Java 8后，永久代被元空间取代，G1成为默认GC。
东方睿赢
10 2
龙大吉
|
1天前
|
Java
Java中，有两种主要的方式来创建和管理线程：`Thread`类和`Runnable`接口。
【6月更文挑战第24天】Java创建线程有两种方式：`Thread`类和`Runnable`接口。`Thread`直接继承受限于单继承，适合简单情况；`Runnable`实现接口可多继承，利于资源共享和任务复用。推荐使用`Runnable`以提高灵活性。启动线程需调用`start()`，`Thread`直接启动，`Runnable`需通过`Thread`实例启动。根据项目需求选择适当方式。
龙大吉
9 2
weixin_836869520
|
1天前
|
Java
Java多线程中notifyAll()方法用法总结
Java多线程中notifyAll()方法用法总结
weixin_836869520
9 1
龙大吉
|
1天前
|
Java
在Java中，死锁是指两个或多个线程互相等待对方释放资源，从而导致所有线程都无法继续执行的情况。
【6月更文挑战第24天】在Java并发中，死锁是多线程互相等待资源导致的僵局。避免死锁的关键策略包括：防止锁嵌套，设定固定的加锁顺序，使用`tryLock`带超时，避免无限等待，减少锁的持有时间，利用高级同步工具如`java.util.concurrent`，以及实施死锁检测和恢复机制。通过这些方法，可以提升程序的并发安全性。
龙大吉
6 1
weixin_836869520
|
4天前
|
安全 Java 程序员
Java多线程详解
Java多线程详解
weixin_836869520
20 3
米诺斯
|
15小时前
|
Java
java线程之异步回调
java线程之异步回调
米诺斯
4 0

热门文章

最新文章

  • 1
    Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
  • 2
    【JAVA】Java 中什么叫单例设计模式？请用 Java 写出线程安全的单例模式
  • 3
    【JAVA】线程的run()和start()有什么区别？
  • 4
    Python并发编程：解析异步IO与多线程
  • 5
    高级主题：Visual Basic 中的多线程和并发编程
  • 6
    高德地图爬虫实践：Java多线程并发处理策略
  • 7
    Python 多线程编程实战：threading 模块的最佳实践
  • 8
    Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
  • 9
    Java串口通信技术探究3：RXTX库线程 优化系统性能的SerialPortEventListener类
  • 10
    多线程入门
  • 1
    Java中的集合框架：深入理解与应用
    67
  • 2
    Java并发编程：理解并使用Future和Callable接口
    28
  • 3
    性能工具之 Java 调试工具 JDB
    60
  • 4
    JAVA云HIS系统医院信息管理源码
    48
  • 5
    Java基于物联网技术的智慧工地云管理平台源码 依托丰富的设备接口标准库，快速接入工地现场各类型设备
    172
  • 6
    [Java基础]——类的生命周期
    24
  • 7
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    43
  • 8
    【java进阶】Java中线程的实现方式
    34
  • 9
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    33
  • 10
    [java进阶]——方法引用改写Lambda表达式
    41

    • 相关课程

    更多
  • 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程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）