多线程

最新推荐文章于 2023-10-01 10:07:28 发布
最新推荐文章于 2023-10-01 10:07:28 发布
阅读量81 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40432088/article/details/104277432
版权

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

第一种方式开辟线程

package com.qianfeng.thread;

public class ThreadCreate {

    public static void main(String[] args) {
        // 线程实例化
        // 1.继承Thread类， 做一个线程子类（自定义线程类）
        MyThread myThread = new MyThread();
        
        // 注意
        // 需要调用start方法， 使线程启动
        // start方法开启一个新的线程，来执行run中的逻辑
        // 如果直接调用run方法，则线程mt不会进入就绪状态
        myThread.start();

        System.out.println("主线程中逻辑执行结束了");
    }

}

/**
 *  这是自定义的线程类
 */
class MyThread extends Thread{

    /**
     *  需要重写run方法
     *  将需要并发执行的任务写到run方法中
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println("子线程的逻辑：" + i);
        }
    }
}

在这里插入图片描述
如果是串行的，主线程一定最后打印

第二种方式

package com.qianfeng.thread;

public class ThreadCreate {

    public static void main(String[] args) {
        // 线程实例化
        // 1.继承Thread类， 做一个线程子类（自定义线程类）
        MyThread myThread = new MyThread();

        // 注意
        // 需要调用start方法， 使线程启动
        // start方法开启一个新的线程，来执行run中的逻辑
        // 如果直接调用run方法，则线程mt不会进入就绪状态
        myThread.start();

        // 2.通过Runnable接口

        Runnable runnable = new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++){
                    System.out.println("线程2的逻辑：" + i);
                }
            }
        };
        
        Thread thread = new Thread(runnable);
        thread.start();

        System.out.println("主线程中逻辑执行结束了");
    }

}

/**
 *  这是自定义的线程类
 */
class MyThread extends Thread{

    /**
     *  需要重写run方法
     *  将需要并发执行的任务写到run方法中
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println("子线程的逻辑：" + i);
        }
    }
}

在这里插入图片描述

线程的命名

package com.qianfeng.thread;

public class ThreadMethod {

    public static void main(String[] args) {
        // 线程的命名
        // 1.实例化一个线程对象
//        Thread thread = new Thread();
//        thread.setName("custom");

        // 2.实例化一个线程对象的同时，通过构造方法对线程进行命名
        // Thread（Runnable r, String name）
//        Thread thread = new Thread(() -> {}, "custome");

        // 3.使用自定义的线程类，在实例化线程对象的同时，进行名称的赋值
        // 需要给线程类添加对应的构造方法
        MyThread2 thread = new MyThread2("custom");

        System.out.println(thread.getName());
    }
}

class MyThread2 extends Thread{

    public MyThread2() {
    }

    public MyThread2(String name){
//        super(name);
        this.setName(name);
    }

}

线程休眠

package com.qianfeng.thread;

public class ThreadMethod {

    public static void main(String[] args) {
        threadSleep();
    }

    private static void threadSleep() {
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
    }
}

class MyThread2 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println(i);
            // 线程休眠
            // 1.参数：毫秒为单位的时间差
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

每一秒打印一个数

线程的优先级

package com.qianfeng.thread;

public class ThreadMethod {

    public static void main(String[] args) {
        threadPriority();
    }

    private static void threadPriority() {
        // 设置线程的优先级，只是修改这个线程可以去抢到cpu时间片的概率
        // 并不是优先级高的线程一定能签到cpu的时间片
        // 优先级的设置，是一个整数[0,10]的整数，默认为5
//        Runnable runnable = new Runnable() {
//            @Override
//            public void run() {
//                for (int i = 0; i < 100; i++){
//                    System.out.println(Thread.currentThread().getName() + ":" + i);
//                }
//            }
//        }
        Runnable runnable = () -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        };

        Thread t1 = new Thread(runnable, "Thread-1");
        Thread t2 = new Thread(runnable, "Thread-2");

        // 设置优先级必须要放到这个线程开始执行（start）之前
        t1.setPriority(10);
        t2.setPriority(1);

        t1.start();
        t2.start();
    }
}

class MyThread2 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println(i);
            // 线程休眠
            // 1.参数：毫秒为单位的时间差
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述

线程的礼让

package com.qianfeng.thread;

public class ThreadMethod {

    public static void main(String[] args) {
        threadYield();
    }

    private static void threadPriority() {
        // 设置线程的优先级，只是修改这个线程可以去抢到cpu时间片的概率
        // 并不是优先级高的线程一定能签到cpu的时间片
        // 优先级的设置，是一个整数[0,10]的整数，默认为5
//        Runnable runnable = new Runnable() {
//            @Override
//            public void run() {
//                for (int i = 0; i < 100; i++){
//                    System.out.println(Thread.currentThread().getName() + ":" + i);
//                }
//            }
//        }
        Runnable runnable = () -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        };

        Thread t1 = new Thread(runnable, "Thread-1");
        Thread t2 = new Thread(runnable, "Thread-2");

        // 设置优先级必须要放到这个线程开始执行（start）之前
        t1.setPriority(10);
        t2.setPriority(1);

        t1.start();
        t2.start();
    }

    /**
     *  线程的礼让
     */
    private static void threadYield() {
        // 线程礼让，指的是当前的运行状态的线程释放自己的cpu资源，由运行状态，回到就绪状态，并重新开始争抢cpu资源
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + ";" + i);
                    if (i == 3) {
                        Thread.yield();
                    }
                }
            }
        };

        Thread t1 = new Thread(r,"thread-1");
        Thread t2 = new Thread(r,"thread-2");

        t1.start();
        t2.start();

    }
}

class MyThread2 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println(i);
            // 线程休眠
            // 1.参数：毫秒为单位的时间差
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述

临界资源问题展示

进程资源不共享，但是线程资源共享

package com.qianfeng.sourceconflict;

public class SourceConflict {

    // 演示临界资源问题
    // 某个景点由4个售票员同时在售票
    public static void main(String[] args) {
        // 实例化4个售票员，用4个线程模拟4个售票员
        Runnable r = () -> {
            while (TicketCenter.restCount >0) {
                System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余" + --TicketCenter.restCount + "张");
            }
        };

        // 用四个线程模拟4个售票员
        Thread t1 = new Thread(r,"thread - 1");
        Thread t2 = new Thread(r,"thread - 2");
        Thread t3 = new Thread(r,"thread - 3");
        Thread t4 = new Thread(r,"thread - 4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

class TicketCenter {
    // 描述剩余的票的数量
    public static int restCount = 100;
}

在这里插入图片描述

解决临界资源问题

同步代码段

package com.qianfeng.sourceconflict;

public class SynchronizedDemo {

    public static void main(String[] args) {
        // 实例化4个售票员，用4个线程模拟4个售票员
        Runnable r = () -> {
            while (TicketCenter.restCount >0) {
                // 对象锁： ""
                // 类锁：
                // 需要保证一点，多个线程看到的锁，需要时同一把锁！！！
                synchronized (SynchronizedDemo.class){
                    if (TicketCenter2.restCount <= 0) {
                        return;
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余" + --TicketCenter2.restCount + "张");
                }
            }
        };

        // 用四个线程模拟4个售票员
        Thread t1 = new Thread(r,"thread - 1");
        Thread t2 = new Thread(r,"thread - 2");
        Thread t3 = new Thread(r,"thread - 3");
        Thread t4 = new Thread(r,"thread - 4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

class TicketCenter2{
    // 描述剩余的票的数量
    public static int restCount = 100;
}

在这里插入图片描述

同步方法

package com.qianfeng.sourceconflict;

public class SynchronizedFunction {

    public static void main(String[] args) {
        // 实例化4个售票员，用4个线程模拟4个售票员
        Runnable r = () -> {
            while (TicketCenter.restCount >0) {
                // 对象锁： ""
                // 类锁：
                // 需要保证一点，多个线程看到的锁，需要时同一把锁！！！
                soldTicket();
            }
        };

        // 用四个线程模拟4个售票员
        Thread t1 = new Thread(r,"thread - 1");
        Thread t2 = new Thread(r,"thread - 2");
        Thread t3 = new Thread(r,"thread - 3");
        Thread t4 = new Thread(r,"thread - 4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }


    /**
     *  同步方法
     *  静态方法： 同步锁就是 类锁 当前类.class
     *  非静态方法： 同步锁 是 this
     */
    private synchronized static void soldTicket() {
        if (TicketCenter.restCount <= 0) {
            return;
        }
        System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余" + --TicketCenter.restCount + "张");
    }
}

在这里插入图片描述

显示锁

package com.qianfeng.sourceconflict;

import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {

    public static void main(String[] args) {

        ReentrantLock lock = new ReentrantLock();

        // 实例化4个售票员，用4个线程模拟4个售票员
        Runnable r = () -> {
            while (TicketCenter2.restCount > 0) {

                // 对临界资源上锁
                lock.lock();

                if (TicketCenter2.restCount <= 0) {
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余" + --TicketCenter2.restCount + "张");

                // 对临界资源解锁
                lock.unlock();
            }
        };

        // 用四个线程模拟4个售票员
        Thread t1 = new Thread(r, "thread - 1");
        Thread t2 = new Thread(r, "thread - 2");
        Thread t3 = new Thread(r, "thread - 3");
        Thread t4 = new Thread(r, "thread - 4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }

}

在这里插入图片描述

死锁

package com.qianfeng.sourceconflict;

public class DeadLock {

    public static void main(String[] args) {
        // 死锁： 多个线程彼此持有对方所需要的锁对象，而不释放自己的锁
        Runnable runnable1 = () -> {
            synchronized ("A") {
                System.out.println("A线程持有了A锁,等待B锁");

                synchronized ("B") {
                    System.out.println("A线程持有了A锁和B锁");
                }
            }
        };

        Runnable runnable2 = () -> {
            synchronized ("B") {
                System.out.println("B线程持有了B锁,等待A锁");

                synchronized ("A"){
                    System.out.println("B线程持有了A锁和B锁");
                }
            }
        };

        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        thread1.start();
        thread2.start();
    }
}

在这里插入图片描述

解决死锁

package com.qianfeng.sourceconflict;

public class DemoLock {

    public static void main(String[] args) {
        // 死锁： 多个线程彼此持有对方所需要的锁对象，而不释放自己的锁

        // wait：等待， 是Object类中的一个方法，当前的线程释放自己的标记，并且让出cpu资源，使得当前的线程进入等待队列中。
        // notify: 通知， 是Object类中的一个方法， 唤醒等待队列中的一个线程，使这个线程进入锁池。
        // notifyAll: 通知， 是Object类中的一个方法，唤醒等待队列中所有的线程，并使这些线程进入锁池。

        Runnable runnable1 = () -> {
            synchronized ("A") {
                System.out.println("A线程持有了A锁,等待B锁");

                try {
                    "A".wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized ("B") {
                    System.out.println("A线程持有了A锁和B锁");
                }
            }
        };

        Runnable runnable2 = () -> {
            synchronized ("B") {
                System.out.println("B线程持有了B锁,等待A锁");

                synchronized ("A"){
                    System.out.println("B线程持有了A锁和B锁");

                    "A".notifyAll();
                }
            }
        };

        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        thread1.start();
        thread2.start();
    }

}

在这里插入图片描述

weixin_40432088
关注
专栏目录
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
C语言多线程操作
热门推荐
技无涯的博客
11-27 1万+
C语言多线程操作 目录 C语言多线程 创建线程 终止线程 注意 信号量机制 参考博文： 返回目录 C语言多线程 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 基于线程的多任务处理是同一程序的片段的并发执行。 多线程程序包含可以同时运行...
Java多线程获取执行结果
Lucifer ZHAO
03-01 3523
一、Thread.join() 特点：一个线程等待另一个线程结束后才能执行。利用此原理我们可以设置一个监控线程用来等待程序线程执行完毕后输出返回结果。 public class Result { private String value; public String getValue() { return value; } public void setValue(String value) { this.value = value;
多线程的创建方式
qq_49005459的博客
10-29 3234
多线程的创建有七种方式： (1)继承Thread类创建线程 (2)实现Runnable接口创建线程 (3)使用匿名内部类的形式创建线程 (4)使用lambda表达式创建线程 (5)使用Callable和Future创建线程 (6)使用线程池例如用Executor框架 (7)spring 的@Async异步注解 1.继承Thread类创建 public class ThreadDemo extends Thread{ //程序执行的代码就在run()方法中 @Override pub
多线程同步
Imzhipo的博客
07-11 3784
多线程 线程同步
Java多线程详解
。。。
07-29 5278
今天我们聊一聊多线程，谈到多线程，很多人就开始难受，这是一个一听就头疼的话题，但是，我希望你在看完这篇文章后能对多线程有一个深入的了解。 案例 那么，首先我就举一个电影院卖票的例子来模拟多线程。 复仇者联盟4上映的那段时间电影院那可是门庭若市啊，那么我们假设现在有一个电影院正在上映复仇者联盟4，共有100张票，而它有三个售票窗口，我们来模拟一下这个电影院的售票情况。 首先创建SellTicket类...
linux多线程
weixin_46485873的博客
07-09 3096
多线程：所有程序并发运行，多条路径可以同时执行 多线程包括：理解线程并发、线程同步方法、线程安全概念 线程指：进程内部得一条执行路径（从主函数的第一行代码到最后一行）主线程：main 子线程：线程函数 比如：fun.... 进程指：一个正在运行的程序 在linux平台创建线程，是内核提供的头文件#include注意编译的时候要加 -lpthreadpthread_create(线程id，默认的属性可以不设置为NULLL，参数函数); 创建线程子线程如下图 有些时候主线......
【C++】基础：多线程介绍与程序示例
DevFrank的博客
02-21 2144
多线程介绍与程序示例
9.1 运用API创建多线程
CSDN
10-01 1万+
在Windows平台下创建多线程有两种方式，读者可以使用`CreateThread`函数，或者使用`beginthreadex`函数均可，两者虽然都可以用于创建多线程环境，但还是存在一些差异的，首先`CreateThread`函数它是`Win32 API`的一部分，而`_beginthreadex`是`C/C++`运行库的一部分，在参数返回值类型方面，`CreateThread`返回线程句柄，而`_beginthreadex`返回线程ID，当然这两者在使用上并没有太大的差异，但为了代码更加通用笔者推荐使用后
多线程下载
哈
10-21 3121
多线程下载 使用多线程下载文件可以很快地完成文件的下载，比如迅雷就是采用了多线程的方式来实现快速下载的。之所以采用多线程的形式会加快下载速度，是因为客户端启动多个线程进行下载时服务器就会为该客户端提供相应的服务，自然客户端就拥有了较快的下载速度。实际上并不是客户端并发的下载线程越多，程序下载速度就越快，，因为当客户端开启太多的并发线程之后，应用程序需要维护每条线程的开销，线程同步的开销，这些开销反...
08-04 多线程之Task
菜鸟爱飞不飞的博客
02-06 4011
目录前言一、Task开启线程的方式1、Task实例化2、Task.Run()静态方法3、TaskFactory二、Task由线程池管理三、父子线程 前言 Task诞生于.NETFramework 3.0，同时支持.NET Core Task被称为C# 中多线程的最佳实现 一、Task开启线程的方式 1、Task实例化 Task task = new Task(() => { Console.WriteLine($"==================new Task start {Th
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
weixin007医院管理系统+Springboot.rar
09-13
所有源码，都是可以运行起来的
5G网络优化：片区满意度交流材料.pptx
最新发布
09-13
5G网络优化
操作系统内可以一键关闭WD
09-13
操作系统内可以一键关闭WD
weixin086基于微信小程序的影院选座系统+ssm.rar
09-13
所有源码，都是可以运行起来的
基于java的学生评奖评优管理系统的设计与实现.docx
09-13
基于java的学生评奖评优管理系统的设计与实现.docx
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值