Java多线程

最新推荐文章于 2024-11-08 14:58:24 发布
最新推荐文章于 2024-11-08 14:58:24 发布
阅读量395 收藏 10
点赞数 7
分类专栏： JAVA 文章标签： java 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tntxd/article/details/137353311
版权

一、线程：

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位

简单理解：应用软件中互相独立，可以同时运行的功能

并发：在同一时刻，有多个指令在单个CPU上交替 执行

并行：在同一时刻，有多个指令在多个CPU上同时执行

二、多线程的实现方式：

①继承Thread类的方式进行实现

代码演示：

package a01threaddemo;

public class MyThread extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"hello world");
        }
    }
}

测试类：

package a01threaddemo;

public class ThreadDemo1 {
    public static void main(String[] args) {
        //多线程的第一种启动方式
        //1.自己定义一个类继承Thread
        //2.重写run方法
        //3.创建子类的对象，并启动线程
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        t1.setName("线程1");
        t2.setName("线程2");
        //开启线程用start
        t1.start();
        t2.start();//两个线程交替执行
    }
}

 运行结果：

②实现Runnable接口的方式进行实现

代码演示：

package a01threaddemo;

public class MyRun implements Runnable{
    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            //获取到当前线程的对象
         /*   Thread t=Thread.currentThread();
            System.out.println(t.getName()+"helloWorld");
            */
            System.out.println(Thread.currentThread().getName()+"helloWorld");
        }
    }
}

测试类：

package a01threaddemo;

public class ThreadDemo2 {
    public static void main(String[] args) {
        //多线程第二种启动方式
        //1.自己定义一个类实现Runnable接口
        //2.重写里面的run方法
        //3.创建自己的类的对象
        //4.创建一个Thread类的对象，并开启线程

        //创建MyRun的对象
        //表示多线程要执行的任务
        MyRun mr=new MyRun();
        //创建线程对象
        Thread t1=new Thread(mr);
        Thread t2=new Thread(mr);

        //给线程设计名字
        t1.setName("线程1");
        t2.setName("线程2");
        //开启线程
        t1.start();
        t2.start();
    }
}

运行结果：两个线程交替执行

 

 ③利用Callable接口和Future接口方式实现

代码演示：

package a01threaddemo;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        //求1~100之间的和
        int sum=0;
        for (int i = 1; i <= 100; i++) {
            sum=sum+i;
        }
        return sum;
    }
}

运行结果：

package a01threaddemo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class ThreadDemo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //多线程的第三种方式
        //特点：可以获取到多线程运行的结果
        //1.创建一个类MyCallable实现Callable接口
        //2.重写call(是有返回值的，返回值表示多线程的运行结果)
        //3.创建MyCallable的对象（表示多线程要执行的任务）
        //4.创建FutureTask的对象（作用：管理多线程运行的结果）
        //5.创建Thread的对象（表示线程）

        MyCallable mc=new MyCallable();
        FutureTask<Integer> ft=new FutureTask<>(mc);
        Thread t1=new Thread(ft);
        t1.start();
        Integer result = ft.get();
        System.out.println(result);

    }
}

三、常见的成员方法： 

1. 前4个代码演示：
package a02threaddemo;

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

    public MyThread(String name) {
        super(name);
    }

    public void run(){
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(getName()+"@"+i);
        }
    }
}

测试类：

package a02threaddemo;

public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        //细节1：如果没有给线程设置名字，线程也是有默认的名字的
        //格式：Thread-X(X序号，从0开始的)
        //细节2：如果我们要给线程设置名字，可以用set方法进行设置，也可以用构造方法进行设置
        //细节3：当JVM虚拟机启动之后，会自动的启动多条线程，其中有一条线程就叫做main线程
        //他的作用就是去调用main方法，并执行里面的代码
        //在以前，我们写的所有的代码都是运行在main线程中的
        //sleep：让线程休眠
        //细节1：哪条线程执行到这个方法，哪条线程就会在这里停留对应的时间
        //细节2：方法的参数：就表示睡眠的时间，单位毫秒
        //细节3：当时间到了之后，线程会自动的醒来，继续执行下面的其他代码



        //1.创建线程的对象
        MyThread t1=new MyThread("线程1");
        MyThread t2=new MyThread("线程2");
        //2.开启线程
        t1.start();
        t2.start();


     /*   Thread t=Thread.currentThread();
        String name = t.getName();
        System.out.println(name);
        */

    /*    System.out.println("1111111111111");
        Thread.sleep(5000);
        System.out.println("222222222");
     */

    }
}
2.线程的优先级：分为抢占式调度和非抢占式调度

Java中是抢占式调度（随机性） 

代码演示：

package a02threaddemo;

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

 测试类：

package a02threaddemo;

import a01threaddemo.MyRun;

public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable mr=new MyRunnable();
        Thread t1=new Thread(mr,"线程1");
        Thread t2=new Thread(mr,"线程2");
//        System.out.println(t1.getPriority());//5
//        System.out.println(t2.getPriority());//默认优先级是5,最小是1，最大是10
//        System.out.println(Thread.currentThread().getPriority());//5
        t1.setPriority(1);
        t2.setPriority(10);
        //优先级越高抢占到CPU的概率越大
        t1.start();
        t2.start();
    }
}

运行结果：

 

 3.守护线程：

细节：当其他的非守护线程执行完毕后，守护线程会陆续结束（并不会执行完所有代码就结束了）

四、 生产者和消费者（常见方法）

void wait()--------->当前线程等待，直到被其他线程唤醒

void notify()-------->随机唤醒单个线程

void notifyAll()-------->唤醒所有线程

等待唤醒机制代码演示

厨师类：

package a03threaddemo;

public class Cook extends Thread {
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    //判断桌子上是否有食物
                    if (Desk.foodFlag == 1) {
                        //如果有就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    } else {
                        //如果没有就制作食物
                        System.out.println("厨师做了一碗面条");
                        //修改桌子上的食物状态
                        Desk.foodFlag = 1;
                        //唤醒等待的消费者开吃
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

吃货类：

package a03threaddemo;

public class Foodie extends Thread{
    public void run(){
        //步骤：
        //1.循环
        //2同步代码块
        //3.判断共享数据是否到了末尾（先写到了末尾因为简单）
        //4.没有到末尾情况，执行核心逻辑

        while(true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else{
                    //先判断桌子上是否有面条
                    if(Desk.foodFlag==0) {
                        //如果没有就等待
                        try {
                            Desk.lock.wait();//让当前线程跟锁进行绑定
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else {
                        //把吃的总数-1
                        Desk.count--;
                        //如果有就开吃
                        System.out.println("吃货正在吃面条，还能再吃" + Desk.count + "碗！！！");
                        //吃完之后唤醒厨师继续做
                        Desk.lock.notifyAll();//唤醒绑定这把锁的所有线程
                        //修改桌子的状态
                        Desk.foodFlag = 0;
                    }
                }
            }
        }
    }
}

桌子类：

package a03threaddemo;

public class Desk {
    //控制生产者和消费者的执行
    //foodFlag 0:没有面条  1：有面条
    //boolean只能控制两条线程，所以如果以后线程变多了，就不能用了
    public static int foodFlag=0;
    //总个数：
    public static int count=10;
    //锁对象
    public static Object lock=new Object();
}

测试类：

package a03threaddemo;

public class ThreadDemo2 {
    public static void main(String[] args) {
        //创建线程对象
        Cook c=new Cook();
        Foodie f=new Foodie();
        //给线程设计名字
        c.setName("厨师");
        f.setName("吃货");
        c.start();
        f.start();

    }
}

运行结果：

 

 等待唤醒机制（阻塞队列方式实现）

生产者和消费者必须使用同一个阻塞队列

厨师类：

package a04threaddemo;

import java.util.concurrent.ArrayBlockingQueue;

public class Cook extends Thread{
    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    public void run(){
        while(true){
            //不断的把面条放在阻塞队列当中
            try {
                queue.put("面条");
                System.out.println("厨师放了一碗面条");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

 吃货类：

package a04threaddemo;

import java.util.concurrent.ArrayBlockingQueue;

public class Foodie extends Thread{
    ArrayBlockingQueue<String> queue;

    public Foodie(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }
    public void run(){
        while(true){
            //不断的从阻塞队列中获取面条
            //不用写锁，代码底层有锁
            try {
                String food = queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

测试类：

package a04threaddemo;

import java.util.concurrent.ArrayBlockingQueue;

public class ThreadDemo {
    public static void main(String[] args) {
        //1.创建阻塞队列的对象
        ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(1);
        //2.创建线程的对象，并把阻塞队列传递过去
        Cook c=new Cook(queue);
        Foodie f=new Foodie(queue);
        c.start();
        f.start();
    }
}

运行结果：会死循环

 

 

空哥sky
关注
专栏目录
java多线程
m0_46702681的博客
06-19 2235
javajava。
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
热门推荐
qq_35716689的博客
03-27 24万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
Java多线程详解
坏蛋阿土的博客
11-06 6625
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
Java多线程读取文件
Mr-Bean的博客
08-16 2472
package com.qwx.test; import java.io.*; /** * @ClassName: ReadFile * @Description: java类作用描述 * @Author: qiaowenxuan * @CreateDate: 2021/8/16$ 18:36$ * @Version: 1.0 */ public class ReadFile { public static void main(String[] args) { Fil
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
Java 多线程 测试
风信子
04-14 1963
Java 多线程 测试1 Callable2 Runnable3 Thread 1 Callable package com.xu.thread; import java.util.concurrent.Callable; /** * @author Administrator */ public class MyCallable implements Callable { @Override public Object call() throws Exception {
JAVA多线程实战
超级氯化钾的博客
07-21 2810
是计算机中的程序关于某数据集合的一次运行活动，，一个线程就是进程中一个单一顺序的控制流，进程是线程的容器，一个进程至少有一个线程，一个进程可以有多个线程OS中是以进程为单位分配资源，如虚拟存储控件、文件描述符。每个线程都有自己的线程栈JVM启动时会自动创建一个主线程，该主线程负责执行main方法。主线程就是运行main方法的线程。.........
Java多线程(四)线程锁
yuanchun的知识整理
11-03 4879
Java多线程(四)线程锁
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 6382
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
spring循环依赖解决方式
qq_36400213的博客
11-04 903
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
最新发布
LJH_laura_li的博客
11-08 177
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 68
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 439
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值