Java 多线程

最新推荐文章于 2024-03-29 02:23:33 发布
最新推荐文章于 2024-03-29 02:23:33 发布
阅读量899 收藏 4
点赞数 2
分类专栏： Java 基础入门 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52861684/article/details/129651028
版权

文章目录

一、实现多线程

1. 进程和线程

① 进程：是正在运行的程序。
是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源。

② 线程：是进程中的单个顺序控制流，是一条执行路径。
如果一个进程只有一条执行路径，则称为单线程程序，相反一个进程如果有多条执行路径，则称为多线程程序。

2. 继承 Thread 类实现多线程

① 定义一个类 MyThread 继承 Thread 类；
② 在 MyThread 类中重写 run() 方法；
③ 创建 MyThread 类的对象；
④ 启动线程。

package com.zxe;

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
    }
}



package com.zxe;

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

run() 方法封装了被线程执行的代码，但是单纯地调用 run 方法多线程并不会生效，而应该调用 start() 方法线程才开始执行，然后由 Java 虚拟机去间接调用此线程的 run() 方法！

2.1 设置和获取线程名称

Thread 类中设置和获取线程名称的方法：
① void setName(String name)：将此线程的名称更改为等于参数 name；
② String getName()：返回此线程的名称。


public void run() {
    for (int i = 0; i < 1000; i++) {
        System.out.println(getName() + ": " + i);
    }
}



MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
mt1.setName("飞机");
mt2.setName("坦克");
mt1.start();
mt2.start();

在这里插入图片描述

除了使用 setName() 方法，我们还可以利用 Thread 的带参构造方法来为线程命名：


package com.zxe;

public class MyThread extends Thread {

    public MyThread() {
    }
    
    public MyThread(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(getName() + ": " + i);
        }
    }
}



package com.zxe;

public class Test {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("飞机");
        MyThread mt2 = new MyThread("坦克");
        mt1.start();
        mt2.start();
    }
}

注意此处用的是 Thread 的带参构造方法，而不是 MyThread，所以需要用 super() 为 Thread 的带参构造方法传参过去！

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

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

public class Test {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
    }
}

在这里插入图片描述

2.2 线程调度

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

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

Thread 类中设置和获取线程优先级的方法：
① public final int getPriority()：返回此线程的优先级；
② public final void setPriority(int newPriority)：更改此线程的优先级。

MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
mt1.setName("高铁");
mt2.setName("飞机");
mt1.setPriority(10);
mt2.setPriority(1);
System.out.println("高铁的优先级为：" + mt1.getPriority() + "，飞机的优先级为：" + mt2.getPriority());
mt1.start();
mt2.start();

在这里插入图片描述

优先级的取值是有范围的，最低为1，最高为10，默认为5，线程优先级高仅仅表示线程获取 CPU 时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到效果！

2.3 线程控制

在这里插入图片描述

//休眠1000毫秒后再开始下一步操作
Thread.sleep(1000);
//mt1线程全部执行完之后才可以开始其他线程，此语句紧贴在 mt1.start() 后面
mt1.join();
//设置守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
mt1.setDaemon(true);

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述


package com.zxe;

public class Test {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        mt1.setName("高铁");
        mt2.setName("飞机");
        //设置主线程名为坦克
        Thread.currentThread().setName("坦克");
        //设置mt1和mt2为守护线程
        mt1.setDaemon(true);
        mt2.setDaemon(true);

        mt1.start();
        mt2.start();

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

当主线程运行完毕之后，剩下的 mt1 和 mt2 都是守护线程，而当运行的线程都为守护线程时，Java 虚拟机将退出，也就是说后面的线程将不再运行，但并不是立即就停止，而是很快就会停止！

2.4 线程生命周期

在这里插入图片描述

3. Runnable 接口实现多线程

① 定义一个类 MyRunnable 实现 Runnable 接口；
② 在 MyRunnable 类中重写 run() 方法；
③ 创建 MyRunnable 类的对象；
④ 创建 Thread 类的对象，把 MyRunnable 对象作为构造方法的参数；
⑤ 启动线程。

//MyRunnable.java

package com.zxe;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + ", " + i);
        }
    }
}



package com.zxe;

public class Test {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr, "高铁");
        Thread t2 = new Thread(mr, "飞机");
        t1.start();
        t2.start();
    }
}

相比继承 Thread 类，实现 Runnable 接口的好处是，它避免了 Java 单继承的局限性，适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想，所以以后我们在写多线程程序的时候要选择实现 Runnable 接口的方式！

二、线程同步

1. 卖票案例

需求：某电影院目前正在上映国产大片，共有 100 张票，请设计一个程序模拟该电影院卖票。

思路：
① 定义一个类 SellTicket 实现 Runnable 接口，里面定义一个成员变量：private int tickets = 100；
② 在 SellTicket 类中重写 run() 方法实现卖票；
③ 判断票数大于 0，就卖票，并告知是哪个窗口卖的；
④ 卖了票之后，总票数要减 1；
⑤ 票没有了，也可能有人来问，所以这里用死循环让卖票动作一直执行；
⑥ 在测试类中创建 SellTicket 类的对象；
⑦ 创建三个 Thread 类的对象，把 SellTicket 对象作为构造方法的参数，并给出对应的窗口名称；
⑧ 启动线程。


package com.zxe;

public class SellTicket implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
                ticket--;
            }
        }
    }
}



package com.zxe;

public class Test {
    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. 解决数据安全问题

判断多线程程序是否会有数据安全问题的标准：
① 是否是多线程环境；
② 是否有共享数据；
③ 是否有多条语句操作共享数据。

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

2.1 同步代码块

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

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

//格式
synchronized(//任意对象) {
    //多条语句操作共享数据的代码
}

//SellTicket.java

package com.zxe;

public class SellTicket implements Runnable {
    private int ticket = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
                    ticket--;
                }
            }
        }
    }
}



package com.zxe;

public class Test {
    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.2 同步方法

package com.zxe;

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

    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {

                synchronized (SellTicket.class) {

                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在售卖第" + tickets + "张票");
                        tickets--;
                    }
                }
            } else {
                sellTicket();
            }
            x++;
        }
    }

    private static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在售卖第" + tickets + "张票");
            tickets--;
        }
    }
}

① 同步方法就是把 synchronized 关键字加到方法上；
② 同步方法的锁对象是 this；
③ 同步静态方法就是把 synchronized 关键字加到静态方法上；
④ 同步静态方法的锁对象是类名.class。

3. 线程安全的类

① StringBuffer
线程安全，可变的字符序列。从版本 JDK5 开始，被 StringBuilder 替代，通常应该使用 StringBuilder 类，因为它支持所有相同的操作，但它更快，因为它不执行同步。

② Vector
从 Java2 平台 v1.2 开始，该类改进了 List 接口，使其成为 Java Collections Framework 的成员，与新的集合实现不同，Vector 被同步，如果不需要线程安全的实现，建议使用 ArrayList 代替 Vector。

③ Hashtable
该类实现了一个哈希表，它将键映射到值，任何非 null 对象都可以用作键或者值。从 Java2 平台 v1.2 开始，该类进行了改进，实现了 Map 接口，使其成为 Java Collections Framework 的成员，与新的集合实现不同，Hashtable 被同步，如果不需要线程安全的实现，建议使用 HashMap 代替 Hashtable。

List<String> list = Collections.synchronizedList(new ArrayList<String>());

通过调用 synchronizedList 方法，就可以将ArrayList 包装成一个线程安全的集合类！

4. Lock 锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5 以后提供了一个新的锁对象 Lock。

Lock 实现提供比使用 synchronized 方法和语句可以获得更广泛的锁定操作。

Lock 中提供了获得锁和释放锁的方法：
① lock()，加锁；
② unlock()，释放锁。

Lock 是接口不能直接实例化，这里采用它的实现类 ReentrantLock 来实例化。

ReentrantLock()：创建一个 ReentrantLock 的实例。


package com.zxe;

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

public class SellTicket implements Runnable {

    private static int tickets = 100;
    private Lock lock = new ReentrantLock();

    @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();
           }
        }
    }

}

我们一般使用 try 和 finally 共同实现加锁和释放锁，这样即使加锁代码出问题了，程序也会释放锁！

三、生产者消费者

所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程用于生产数据，一类是消费者线程用于消费数据。

为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库。
生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为。

为了体现生产和消费过程中的等待和唤醒，Java 就提供了几个方法供我们使用，这几个方法在 Object 类中：

在这里插入图片描述

下面是一个案例，送奶工将牛奶放入奶箱中，等待顾客取走。

//Box.java

package com.zxe;

public class Box {
    private int milk;
    //默认奶箱没奶
    private boolean flag = false;

    public synchronized void put(int milk) {
        //如果奶箱还有奶，则等待被拿走
        if (flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果奶箱为空，则放奶
        this.milk = milk;
        System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");
        flag = true;
        notifyAll();
    }
    public synchronized void get() {
        //如果奶箱没奶，则等待生产者生产
        if (!flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("顾客拿到第" + milk + "瓶奶");
        flag = false;
        notifyAll();
    }
}


//Producer.java

package com.zxe;

public class Producer implements Runnable {
    private Box b;

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

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


//Customer.java

package com.zxe;

public class Customer implements Runnable {
    private Box b;

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

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


//Test.java

package com.zxe;

public class Test {
    public static void main(String[] args) {
        Box b = new Box();
        Producer p = new Producer(b);
        Customer c = new Customer(b);
        Thread producer = new Thread(p);
        Thread customer = new Thread(c);
        producer.start();
        customer.start();
    }
}

在这里插入图片描述

栈老师不回家
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java多线程
05-02
Java多线程
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解和实践经验。
Java多线程的五种实现方式，Java初级项目案例
最新发布
2301_78146994的博客
03-29 965
做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务。
JAVA多线程详解（超详细）
七星太极阵的博客
08-05 1万+
线程简介，线程的创建方式，多线程并发问题
Java多线程实现同时输出
09-02
主要介绍了Java多线程实现同时打印的相关资料,需要的朋友可以参考下
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
java多线程（超详细）
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
一篇搞懂Java多线程（全网最细）
让优秀成为一种习惯！
07-22 7119
Java多线程是一种强大而有趣的编程概念。它允许程序同时执行多个任务，就像一个宏大的交响乐团。每个线程都是一个独立的执行路径，有自己的速度和优先级。那么，我们期待多线程能给我们带来什么呢？
Java多线程的同步机制：synchronized
you can you up up up的博客
09-14 1106
如果程序是单线程的，就不必担心此线程在执行时被其他线程“打扰”，就像在现实世界中，在一段时间内如果只能完成一件事情，不用担心做这件事情被其他事情打扰。但是，如果程序中同时使用多线程，好比现实中的“两个人同时通过一扇门”，这时就需要控制，否则容易引起阻塞。 为了处理这种共享资源竞争，可以使用同步机制。所谓同步机制，指的是两个线程同时作用在一个对象上，应该保持对象数据的统一性和整体性。Java 提供 synchronized 关键字，为防止资源冲突提供了内置支持。共享资源一般是文件、输入/输出端口或打印机。 在
Java多线程编程总结
01-31
下面的内容是很早之前写的，内容不够充实，而且是基于Java1.4的内容，Java5之后，线程并发部分扩展了相当多的内容，因此建议大家看上面的系列文章的内容，与时俱进，跟上Java发展的步伐。要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来批量执行任务。现在的操作系统都是多任务操作系统，每个运行的任务就是操作系统所做的一件事情，比如你在听歌的同时还在用MSN和好友聊天。听歌和聊天就是两个任务，这个两个任务是“同时”进行的
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
一文搞懂Java多线程，讲的很详细，收藏起来慢慢看
BASK2312的博客
07-06 3084
多线程是指在一个程序中同时执行多个线程，每个线程都有自己独立的执行路径。在多线程中，程序的执行可以同时进行多个任务，从而提高系统的资源利用率和响应性能。在传统的单线程编程模型中，程序按照顺序执行，一次只处理一个任务。这种方式在某些情况下可能会导致效率低下或者无法满足需求。而多线程通过将任务拆分为多个子任务，并且在不同的线程上同时执行，从而实现并发处理。
Java多线程（超详细）
qq_43390466的博客
05-23 2178
多任务处理有两种：基于进程进程是一种"自包容"的运行程序，有操作系统直接管理，直接运行，有自己的地址空间，每一个进程开启都会消耗内存基于进程的特点是允许计算机同时运行多个程序基于线程在一个程序中，能独立运行的程序片段叫做“线程”，线程是进程内部单一的顺序控制流一个进程拥有多个线程。多个线程共享一个进程的内存空间基于线程的多任务处理环境中，线程是最小的处理单位。
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4536
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java多线程（超详解）
m0_52896041的博客
10-26 1万+
Java多线程（超详解）
Java多线程详解，一篇文章读懂多线程。
brokyz
04-24 400
文章目录1. 基本概念2. 线程的创建和启动2.1. 多线程实现的原理2.2.多线程的创建，方式一：继承于Thread类2.3.多线程的创建，方式一：创建Thread匿名子类（也属于方法一）2.4. 多线程的创建，方式二：实现Runnable接口2.4.1. 比较创建线程的两种方式2.5. 多线程的创建，方式三：实现Callable接口2.6. 多线程的创建，方式四：线程池3. Thread类的常用方法4. 线程的调度4.1. cpu的调度策略4.2. Java的调度算法：5. 线程的生命周期6. 线程的同
Java多线程（吐血超详细整理）
♚焕蓝·未来的博客
04-01 1998
这一篇看完多线程还不明白？我不信！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

栈老师不回家

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值