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

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
目录
相关文章
joseph_
|
3天前
|
Java
【Java基础】输入输出流（IO流）
Java基础、输入输出流、IO流、流的概念、输入输出流的类层次结构图、使用 InputStream 和 OutputStream流类、使用 Reader 和 Writer 流类
joseph_
16 1
一只大鸽子
|
2天前
|
监控 Java API
Java 程序设计 第八章 线程
Java 程序设计 第八章 线程
一只大鸽子
11 1
安于堂前燕
|
2天前
|
存储 安全 Java
Java多线程编程--JUC
Java多线程编程
安于堂前燕
49 2
Jack_hrx
|
2天前
|
缓存 NoSQL Java
Java高并发实战：利用线程池和Redis实现高效数据入库
Java高并发实战：利用线程池和Redis实现高效数据入库
Jack_hrx
12 0
绿水长流*z
|
3天前
|
Java API
详细探究Java多线程的线程状态变化
Java多线程的线程状态主要有六种：新建（NEW）、可运行（RUNNABLE）、阻塞（BLOCKED）、等待（WAITING）、超时等待（TIMED_WAITING）和终止（TERMINATED）。线程创建后处于NEW状态，调用start()后进入RUNNABLE状态，表示准备好运行。当线程获得CPU资源，开始执行run()方法时，它处于运行状态。线程可以因等待锁或调用sleep()等方法进入BLOCKED或等待状态。线程完成任务或发生异常后，会进入TERMINATED状态。
绿水长流*z
12 5
绿水长流*z
|
3天前
|
存储 安全 Java
Java多线程中线程安全问题
Java多线程中的线程安全问题主要涉及多线程环境下对共享资源的访问可能导致的数据损坏或不一致。线程安全的核心在于确保在多线程调度顺序不确定的情况下，代码的执行结果始终正确。常见原因包括线程调度随机性、共享数据修改以及原子性问题。解决线程安全问题通常需要采用同步机制，如使用synchronized关键字或Lock接口，以确保同一时间只有一个线程能够访问特定资源，从而保持数据的一致性和正确性。
绿水长流*z
10 1
绿水长流*z
|
3天前
|
监控 安全 Java
Java多线程的使用
Java多线程允许程序同时执行多个任务，提高了系统的整体性能和响应速度。通过创建Thread类或其子类的实例，或使用Runnable接口，Java开发者可以定义并发执行的代码段。多线程在处理复杂任务、资源共享、网络通信等方面具有显著优势，但也需要注意线程安全、同步和死锁等问题。Java提供了丰富的API和工具来处理这些并发问题，使多线程编程更加高效和可靠。
绿水长流*z
8 2
JavaPub
|
3天前
|
API
java-多线程-CountDownLatch(闭锁) CyclicBarrier(栅栏) Semaphore(信号量)-
java-多线程-CountDownLatch(闭锁) CyclicBarrier(栅栏) Semaphore(信号量)-
JavaPub
7 1
hsfxuebao
|
3天前
|
安全 Java 程序员
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题（二）
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题（二）
hsfxuebao
23 4
hsfxuebao
|
3天前
|
Java 程序员 调度
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题（一）
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题（一）
hsfxuebao
22 0
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题（一）

热门文章

最新文章

  • 1
    Java:如何封装集合
  • 2
    r22 tools cause java.lang.VerifyError when building from ant script
  • 3
    在Eclipse中将Java项目打包为jar
  • 4
    深入探索 Java 中的 @Test 注解：优化单元测试流程的利器
  • 5
    后浪拍前浪-覆写父类方法 | 带你学《Java面向对象编程》之三十九
  • 6
    Java设计模式之代理模式
  • 7
    【Java数据结构的实现】之系列二栈的介绍
  • 8
    java 小数点取2位并且四舍五入
  • 9
    第三章 AOP 通过Java API创建增强
  • 10
    2013编程之美资格赛之树上的三角形（Java实现）
  • 1
    【java进阶】Java中线程的实现方式
    33
  • 2
    深入理解 Java 多线程、Lambda 表达式及线程安全最佳实践
    139
  • 3
    【C++】—— C++11之线程库
    49
  • 4
    C/C++ 线程超详细讲解（系统性学习day10）
    39
  • 5
    Swing通过后台线程实现页面更新
    33
  • 6
    Java中的线程安全集合
    79
  • 7
    浅析Python自带的线程池和进程池
    195
  • 8
    Python使用多线程解析超大日志文件
    101
  • 9
    3段代码详解python中的单线程、多线程和多进程
    36
  • 10
    深入解析 Python asyncio 库：如何使用线程池实现高效异步编程
    140

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • 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程序的编译与运行
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考