多线程搭建及应用

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量97 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48508643/article/details/128032464
版权

多线程–k7

真正的多线程 — 需要多核CPU支持

单核Cup通过切换实现的看起来像是多线程的结果（了解）

ArrayList本身是线性不安全的 可以通过 Collections.synchronized(list) 方法吧list转换成线性安全的

创建和使用线程

继承Thread类、 实现Runnable接口、实现Callable接口、线程池

1.如何自定义线程类

​ 1）继承Thread类

定义三个类继承Thread类


/**
 * 创建线程的方式，继承Thread类
 * 1.继承Thread类
 * 2.重写Thread类中的run方法
 */
public class Chat extends Thread{
    //重写Thread类中的run方法---线程做的所有的工作都在run方法中
    @Override
    public void run(){
        for (int i  = 0; i < 10 ; i++) {
            System.out.println("聊天...");
            //延时
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Drink extends Thread{
    //重写Thread类中的run方法---线程做的所有的工作都在run方法中
    @Override
    public void run(){
        for (int i  = 0; i < 10 ; i++) {
            System.out.println("喝点小酒...");
            //延时
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Eat extends Thread{
    //重写Thread类中的run方法---线程做的所有的工作都在run方法中
    @Override
    public void run(){
        for (int i  = 0; i < 10 ; i++) {
            System.out.println("吃个饭...");
            //延时
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


/**
 * java多线程编程 --- 本质 自定义线程类并创建自定义线程类的对象
 * 1.如何自定义线程类
 *          1）继承Thread类
 *          2）实现Runnable接口
 */
public class MyTest1 {
    public static void main(String[] args) {
        //创建自定义线程类的对象
        Chat chat = new Chat();
        Drink drink = new Drink();
        Eat eat = new Eat();

        //启动线程  --- 线程的start方法，一定不要直接调用run方法
        chat.start();
        drink.start();
        eat.start();
    }
}

​ 2）实现Runnable接口 （避免了单继承的局限性 适合多线程共享同一份资源）

还是那三个类 这次让他们实现Runnable接口

public class ChatThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("聊天...");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

另外两个类同上仿写

public class MyTest {
    public static void main(String[] args) {
        ChatThread chatThread = new ChatThread();
        DrinkThread drinkThread = new DrinkThread();
        EatThread eatThread = new EatThread();

        //创建线程
        Thread chat = new Thread(chatThread);
        Thread drink= new Thread(drinkThread);
        Thread eat = new Thread(eatThread);
        //匿名内部类
        Thread sing = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("唱歌...");
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        //创建线程
        chat.start();
        drink.start();
        eat.start();
        sing.start();

    }
}

2.Thread 常用的方法

先定义一个类继承Tread类


public class MyThread extends Thread{
    @Override
    public void run(){
        //getName() 获取线程的名字
        System.out.println(Thread.currentThread().getName() + "************************************************");
    }
}

现在堆Thread常用的方法进行测试

public class MyTest1 {
    public static void main(String[] args) {
        /**
         * Thread方法
         * 1.staart() 启动线程，不能直接调用run方法
         * 2.run（） 线程在被调用时执行的操作
         * 3.getName（） 获取当前线程的名称
         * 4.setName（） 设置线程的名称，如果没有设置，线程存在默认的名字
         * 5.currentThread（） 返回当前的线程
         *
         * main方法自身也是一个线程
         */

        //设置main线程的名字
        Thread.currentThread().setName("主线程");
        //创建线程对象
        MyThread myThread = new MyThread();
        //设置线程的名字
        myThread.setName("线程A");

        //启动线程
        myThread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " ++++++++++++++++++++++++++++++++++++++++++++++ ");
        }
    }
}

3.线程的调度


public class MyTest2 {
    public static void main(String[] args) throws InterruptedException {
        /**
         * 线程的调度
         * 策略：
         * 1.基于时间片轮转  时间片---非常非常短的时间间隔 轮转--轮流
         * 2.抢占式：高优先级的线程抢占CPU 概率 优先级高的线程运行的概率大
         */
        //获取线程的优先级 --- 默认是5
        System.out.println(Thread.currentThread().getName()+ "优先级" + Thread.currentThread().getPriority());
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);//1

        MyThread myThread = new MyThread();
        //设置线程的优先级
        myThread.setPriority(Thread.MAX_PRIORITY);//10
        System.out.println(myThread.getName()+"优先级"+myThread.getPriority());
        myThread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "++++++++++++++++++++++++++++++++");
            if(i == 2){
                myThread.join();
            }
        }


    }

4.线程同步

线程安全问题：多线程共享一份资源就会出现线程安全问题

请添加图片描述

线程同步的三种方式：

1.synchronized代码块
2.synchronized方法
3.Lock锁（了解）
线性安全的单例设计模式–懒汉式
//synchronized代码块方式
public class SingleObject {
    private static SingleObject obj = null;
    
    private SingleObject() {
        
    }
    
    public static SingleObject getInstance() {
        synchronized(SingleObject.class) {
            if(obj == null) {
                obj = new SingleObject();
            }
        }
        return obj;
    }
}

//synchronized方法方式
public class SingleObject {
    private static SingleObject obj = null;
    
    private SingleObject() {
        
    }
    
    public static synchronized SingleObject getInstance() {
        if(obj == null) {
            obj = new SingleObject();
        }
        return obj;
    }
}

//Lock方式
public class SingleObject {
    private static SingleObject obj = null;
    private ReentrantLock lock = new ReentrantLock(true);
    
    private SingleObject() {
        
    }
    
    public static SingleObject getInstance() {
        try {
            lock.lock();
            if(obj == null) {
                obj = new SingleObject();
            }
        } finally {
            lock.unlock();
        }
        return obj;
    }
}

5.线程通信

  • wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行；
  • notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待；
  • notifyAll()：唤醒正在排队等待资源的所有线程结束等待。

以上三个方法只有在synchronized方法或synchronized代码块中才能使用。

package com.sdut.k7.text1;

/**
 * 线程通信
 */
public class Window implements  Runnable{
    private int count = 1;//1~100
    /**
     * wait() 令当前线程挂起并放弃CPU、同步资源并等待
     *
     * notify（） 唤醒正在排队等待同步资源的线程中优先级最高者结束等待；
     */
    @Override
    public void run() {
        while (true) {
            //synchronized 代码块
            synchronized (Object.class) {
                Object.class.notify();
                if (count <= 100) {
                    System.out.println(Thread.currentThread().getName() + "卖出编号为" + count + "的票");
                    count++;
                } else {
                    break;
                }
                try {
                    Object.class.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}



/**
 * 模拟三个窗口售票 --- 三个窗口销售同一份票  100张
 * 1）100张票被三个窗口共享
 * 2）如何创建三个窗口 --- 三个线程
 * 实现Runnable接口
 *
 * 线程同步
 */
public class MyTest1 {
    public static void main(String[] args) {
        Window window = new Window();
        Thread w1 = new Thread(window);
        Thread w2 = new Thread(window);
        Thread w3 = new Thread(window);

        w1.start();
        w2.start();
        w3.start();

    }
}

总结：

多线程

​ 程序：静

​ 进程；动

​ 线程：main

​ main JavaSe进程

创建线程的方式

1）继承Thread类

​ *自定义线程类，继承Thread类

​ *重写Thread类中的run方法 run（）—线程所有的操作都写在run（）方法中

​ *根据自定义线程类创建线程对象

​ *start（）

2）实现Rannable接口

​ *自定义线程类，实现Rannable接口

​ *重写Rannable接口中的run方法 run（）—线程所有的操作都写在run（）方法中

​ *根据自定义线程类创建线程对象

​ *创建Thread类对象，将上一步的对象传递到构造方法中

​ *start（）

Thread常用的方法

线程的调度

线程同步

线程通信

** 生产者与消费者案例 **

引入：生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个线程——即所谓的生产者和消费者——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。
请添加图片描述
请添加图片描述
请添加图片描述

请添加图片描述

创建线程的第三种方式

实现Callable接口

与使用Runnable相比， Callable功能更强大些

  • 相比run()方法，可以有返回值；

  • 方法可以抛出异常；

  • 支持泛型的返回值；

  • 需要借助FutureTask类，比如获取返回结果。

    import java.util.concurrent.Callable;

/**
 * 使用实现Callable接口的方式创建线程
 */
public class NumThread implements Callable<Integer> {

    //重写call方法
    @Override
    public Integer call() throws Exception {
        //1+2+3+4+...+100
        int sum = 0;
        for(int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

public class MyTest8 {
    public static void main(String[] args) {
        NumThread numThread = new NumThread();
        FutureTask<Integer> task = new FutureTask<>(numThread);
        //创建线程
        Thread thread = new Thread(task);
        //启动线程
        thread.start();
        //设置线程优先级
        thread.setPriority(Thread.MAX_PRIORITY);

        try {
            Integer sum = task.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

创建线程的第四种方式–线程池

1.池化技术

​ |— 线程池

​ |— 连接池

​ |— 内存池

2.为什么要使用池化技术

​ 在系统刚启动还没创建很多线程的时候就先把线程创建好放到池子里 到时候访问就不用创建大量线程 直接访问就行 大大提高性能

public class NumberThread implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class NumberThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if(i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


public class MyTest9{
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        NumberThread numberThread = new NumberThread();
        NumberThread1 numberThread1 = new NumberThread1();

        //执行线程
        service.execute(numberThread);
        service.execute(numberThread1);

        //关闭线程
        service.shutdown();
    }
}

00; i++) {
if(i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + “:” + i);
}
}
}
}

public class MyTest9{
public static void main(String[] args) {
//创建线程池
ExecutorService service = Executors.newFixedThreadPool(10);
NumberThread numberThread = new NumberThread();
NumberThread1 numberThread1 = new NumberThread1();

    //执行线程
    service.execute(numberThread);
    service.execute(numberThread1);

    //关闭线程
    service.shutdown();
}

}
愉悦的周先生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
PHP7多线程搭建教程
10-19
然而，随着技术的发展，PHP也开始支持多线程，特别是在PHP7及更高版本中。在本教程中，我们将深入探讨如何在PHP7环境中搭建多线程功能。 首先，多线程在编程中是一种并发执行任务的方式，它允许程序同时执行多个...
微生物群落组装过程（assembly processes）
weixin_44557372的博客
04-21 2万+
微生物群落组装过程
多线程(一)：创建线程和线程的常用方法
热门推荐
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
线程创建的四种方式
m0_37840000的博客
03-30 18万+
java中创建线程的四种方法以及区别 Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 4）使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的方法。 --...
一文看完最详细的线程创建方式
菜鸟在路上
04-15 408
我们都知道新建线程有三种方式，分别是： 继承Thread类； 实现runnable接口； 实现callable接口； 由于各种方式的写法多样，有时候会造成初学者的困扰，通过本文你可以完整学习到创建线程的各种方式。 这是关于lambda表达式的基础知识，可以先不看，请往下阅读，如有问题回过头来再看。http://www.codebaoku.com/it-java/it-java-224741.html 继承Thread 1、最初级的写法 public class ThreadTest exte
线程的几种创建方式
weixin_49796164的博客
03-01 3732
今天突然用到线程池，就复习下线程这块，记录下工作中常用的知识
多线程Web服务器的搭建与实现
沉蕴陌鹭的博客
05-11 2433
多线程Web服务器的搭建与实现实验目的实验任务实验思路和过程实验代码以及分析代码测试问题总结谢谢观看 实验目的 1. 熟悉简单网络的搭建与基本配置； 2. 熟悉socket、多线程编程； 3. 熟悉JDK编程工具的基本使用； 4. 熟悉HTTP协议； 5. 熟悉Web服务器的基本工作原理和配置。 实验任务 以JDK为开发工具，利用Socket通信机制实现一个多线程的WEB服务器，该服务器具有以下功能： 1， 能够并行服务于多个请求。 2，对于每个请求，显示接收到的HTTP请求报文的内容，并产生适当的响应
Linux多线程
2021dragon的博客
02-12 6854
文章目录Linux线程概念什么是线程线程的优点线程的缺点线程异常线程用途Linux进程VS线程进程和线程进程的多个线程共享关于进程线程的问题Linux线程控制POSIX线程库创建线程线程终止线程等待分离线程Linux线程互斥进程线程间的互斥相关背景概念互斥量mutex互斥量的接口互斥量实现原理探究可重入VS线程安全概念常见的线程不安全的情况常见的线程安全的情况常见的不可重入的情况常见的可重入的情况可重入与线程安全联系可重入与线程安全区别常见锁概念死锁死锁的四个必要条件避免死锁Linux线程同步条件变量同步概
python实现多线程
qq_35778860的博客
09-11 6292
本文转载于上面的链接. 文章目录1 线程基本概念1.1 线程是什么？1.2 线程和进程关系？2 Python线程模块3 线程间同步4 线程池4.1 传统多线程问题？4.2 线程池基本原理：5 协程5.2 Send来了6. python 进行并发编程6.1 使用asyncio6.2 使用async/await7 小结 1 线程基本概念 1.1 线程是什么？ 线程是指进程内的一个执行单元...
java快递柜多线程+网络编程
10-10
该项目提供了一个很好的学习平台，可以深入理解Java多线程和网络编程的实际应用，同时也能锻炼解决并发和网络通信问题的能力。通过对源码的分析和实践，开发者可以提升自己在这些核心领域的技术水平。
毕设项目：使用Pyqt5搭建YOLO系列多线程目标检测系统.zip
08-27
该项目是一个毕业设计项目，主要利用Python的PyQT5库构建了一个基于YOLO（You Only Look Once）系列模型的多线程目标检测系统。这个系统旨在高效地处理图像和视频流，通过并行化处理来提升目标检测的速度。下面将...
实例讲解php实现多线程
01-20
【PHP实现多线程】 ...以上就是关于PHP实现多线程的相关知识点，包括`exec`函数的使用和pthreads扩展的安装及应用。通过理解这些概念和实践，开发者可以更好地在PHP环境中进行并发编程，提升程序性能。
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1176
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 473
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 228
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1934
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1325
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 991
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
"多线程并发编程技巧及应用篇
并发编程的应用主要目的是充分利用CPU资源，通过多线程的方式提高程序的执行效率。为了达到这个目的，可以采取一些特定的方法和工具。 首先，为了分配合适的核，可以使用虚拟机来进行设置。通过虚拟机的配置，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值