多线程详述

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量68 收藏
点赞数
文章标签： java 多线程 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44162147/article/details/112120292
版权

多线程中知识点详解

文章目录

前言

        随着大家的不断学习，恭喜大家进入多线程的学习阶段，在学习之前，可以了解一下本篇文章，可以让同学们学习的更加通透。

一、线程和进程的区别：

​ **进程：**进程是内存中运行的应用程序，每个进程拥有独立的内存空间。

​ **线程：**是进程中的一个执行路径，线程可以并发，一个进程至少有一个线程

​ 线程是在进程基础上的进一步划分，一个进程可有多条线程，

二、创建线程的两种方式：

（1）继承Thread类

public class ThreadTest{
    public static void main(String[] args){
        MyThread t1 = new MyThread();	//创建线程对象
        t1.start();		//线程启动
    }
    static class MyThread extends Thread{		//继承Thread类
        public void run(){		//任务
            System.out.println("Thead1线程执行了")
        }
    }
}

（2）实现Runnable接口

public class RunnableTest{
    public static void main(String[] args){
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        t1.start();
    }
    static class MyRunnable implements Runnable{
        public void run(){
            System.out.println("Thread线程执行了！");
        }
    }
}

三、Thread中常用的构造器及方法

​ 1、构造器

​ （1）、Thread() 无参构造方法

​ （2）、Thread(Runnable target) 传一个Runnable接口的实现子类

​ （3）、Thread(Runnable target,String name) 传一个Runnable接口的实现子类并设置线程名

​ 2、常用方法

​ （1）、start() void

​ 启动线程。

​ （2）、currentThread static Thread

​ 返回当前正在执行的线程对象的引用 一般使用Thead.currentThread.getName()来获取线程名称。

​ （3）、getId() long

​ 返回当前进程的表示，作用于getName()相同。

​ （4）、getName() String

​ 返回该线程的名称。

​ （5）、getPriority int

​ 返回该线程的优先级。

​ （6）、setPriority(int newPriority) void

​ 设置线程的优先级。

​ MAX_PRIORITY: 线程可以拥有的最大优先级。 10

​ MIN_PRIORITY:线程可以拥有的最低优先级。 1

​ NORM_PRIORITY:分配给线程的默认优先级。 5

​ （7）、interrupt() void

​ 中断此线程，相当于打一个中断标记。

​ （8）、setDaemon(boolean on) void

​ 设置当前线程为守护线程

​ （9）、setName(String name) void

​ 设置该线程的名字。

​ （10）、sleep(long millis) static void

​ 使当前线程休眠

​ （11）、toString String

​ 将当前线程作为字符串输出。

四、线程安全----隐式锁与显式锁

​ 线程安全：所谓线程安全就是所需线程不能并发，需要排队执行。

​ 1、隐式锁：隐式锁分为同步代码块和同步方法两种实现方式，都是运用synchronized关键字，并并且都是创建锁后自动开关锁。

//模拟购票实现：synchronized代码块
public class Demo1{
    public static void main(String[] args){
        Ticket t1 = new Ticket();
        t1.start();
    }
    static class Ticket extends Thread{
        private int count = 10;	//初始票数为10张票
        public void run(){
            while(true){
                synchronized(this){		//synchronized代码块
                    if(count>0){
                        System.out.println("正在出票中····");
                        count--;
                        System.out.println("余票为："+i);
                    }
                }
            }
        }
    }
}

需要注意的一点：

​ 在使用synchronize(){}代码块时，括号中的内容必须是实现同一个任务的共享的对象。

//模拟购票实现：synchronized 同步方法
public class Demo2 {
    public static void main(String[] args) {
        Object o = new Object();
        // 同步方法
        Runnable run = new Ticket();
        new Thread(run).start();	//启动第一个线程
        new Thread(run).start();	//启动第二个线程
        new Thread(run).start();	//启动第三个线程
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;	//初始票数为10张
        @Override
        public void run() {

            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        public synchronized boolean sale(){	//需要排队执行的代码
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);	//休眠1秒，方便看的更细致
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;
        }
    }
}

2、显式锁 Lock：隐式锁更倾向于面向对象，是先创建锁对象，然后调用方法，开关锁。

public class Demo3{
    public static void main(String[] args){
        Ticket t1 = new Ticket();
        t1.start();
    }
    static class Ticket extends Thread{
        private Lock lock = new ReentrantLock();
        private int count = 10;
        public void run(){
            while(true){
                lock.lock();	//上锁
                if(count>0){
                    System.out.println("正在出票中····");
                    count--;
                    System.out.println("余票为："+i);
                }
                lock.unlock();		//解锁
            }
        }
    }
}

五、公平锁与非公平锁

​ 1、定义及优缺点：

​ 非公平锁：公平锁是指多个线程按照申请锁的顺序来获得锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。

​ 优点：等待锁的线程不会饿死。

​ 缺点：效率较低。

​ 非公平锁：非公平锁是多个线程加锁时直接尝试获得锁，获取不到才会进入等待队列的队尾等待。

​ 优点：效率高，线程有几率不阻塞获得锁。

​ 缺点：在队列中的线程有几率会饿死，或者要等待很久才能获得锁。

​ 2、Java中的公平锁与非公平锁

​ （1）隐式锁全部为非公平锁，因为是抢占式调度。

​ （2）在显示锁中，在创建Lock对象时，(Lock lock = new ReentrantLock())，括号中可以传一个布尔类型值，传入true则为公平锁，否

则为非公平锁，默认情况为false。

六、死锁

​ 1、死锁产生的条件：

​ (1）互斥。共享资源同时只能被一个线程访问。

​ (2）占有且等待。线程T1在取得共享资源A的时候，请求等待资源B的时候并不释放资源A。

​ (3）不可抢占。其他线程不能强行抢占线程的资源。

​ (4）循环等待条件。线程T1在持有资源A1，同时在请求等待获取资源B，线程T2在持有资源B,然后在请求等待线程T1的持有资源，

形成了交叉闭环申请。

七、线程池技术

Java通过Executors提供四种线程池，分别为：

newCashedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool ：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool： 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor： 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO,

LIFO, 优先级)执行。

//缓存线程池：
public class CashedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        });
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+
                        "线程启动了！！！");
            }
        });
    }
}
/*执行结果：
		pool-1-thread-1线程启动了！！！
		pool-1-thread-2线程启动了！！！
		pool-1-thread-2线程启动了！！！
*/

//不定长线程池
public class FixedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        });service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        });
    }
}
/*执行结果：
		pool-1-thread-1线程启动了！！！
		pool-1-thread-2线程启动了！！！
		pool-1-thread-1线程启动了！！！
*/

//单线程线程池
public class SingleThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        });
    }
}
/*执行结果：
	pool-1-thread-1线程启动了！！！
	pool-1-thread-1线程启动了！！！
*/

//周期性定长线程池
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolTest {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        /*执行一次
         * 第一个参数：定时执行的任务
         * 第二个参数：第一次执行任务的延迟时间
         * 第三个参数：时间单位
        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        },2, TimeUnit.SECONDS);*/
        /**
         * 第一个参数：定时执行的任务
         * 第二个参数：第一次执行任务的延迟时间
         * 第三个参数：周期性时间（每隔多长时间执行一次）
         * 第四个参数：时间单位
         */
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了！！！");
            }
        },5,2,TimeUnit.SECONDS);
    }
}

八、lambda表达式

public class LambdaTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> System.out.println("线程执行了"),"t1");
        t1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}

总结

            以上就是今天要分享的内容，本篇文章是个人笔记产物，希望大家能够保持对学习的热情，努力学习。
码农梦想家
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程调优
haponchang的博客
04-14 649
首先，多线程操作导致了上下文切换。 什么是上下文切换 在单个处理器的时期，操作系统就能处理多线程并发任务。处理器给每个线程分配 CPU 时间片（Time Slice），线程在分配获得的时间片内执行任务。 CPU 时间片是 CPU 分配给每个线程执行的时间段，一般为几十毫秒。在这么短的时间内线程互相切换，我们根本感觉不到，所以看上去就好像是同时进行的一样。 时间片决定了一个线程可以连续占用处理器运行的时长。当一个线程的时间片用完了，或者因自身原因被迫暂停运行了，这个时候，另外一个线程（可以是同一个线程
FX三菱上位机通讯多线程2合一实例
05-22
本文将详述“FX三菱上位机通讯多线程2合一实例”中的关键知识点，帮助读者理解如何在单线程和多线程环境中实现与FX系列PLC的有效通信。 首先，我们关注的是“FX系列上位机通讯”。FX系列是三菱电机推出的一系列小型...
Java技术栈——Java多线程详述
入门程序猿的博客
09-20 3307
多线程https://blog.csdn.net/u012403290/article/details/64910926 对于synchronized与lock，看懂这个就足够了，不需要再深入 其实synchronized映射成字节码指令就是增加来两个指令：monitorenter和monitorexit。当一条线程进行执行的遇到monitorenter指令的时候，它会去尝试获得锁，如果获得锁那么锁计数+1（为什么会加一呢，因为它是一个可重入锁，所以需要用这个锁计数判断锁的情况），如果没有获得锁，那么阻塞。
【Linux】多线程详述
码农印象
03-04 251
前言一、线程的概念（复习）-铺垫1.理解（Linux平台）2.线程的资源3.线程优点4.线程缺点二、Linux线程ID和进程ID 一、线程的概念（复习）-铺垫 进程是分配系统资源的基本单位 线程是一个标准的进程(一个执行流的进程) Linux线程图解 1.理解（Linux平台） 线程是在进程的内部运行的：线程是在进程的地址空间内运行的，共享一份虚拟地址空间。 线程大部分资源都是共享的。（共用...
详述线程间协作
m0_46383618的博客
02-06 224
例如： 上部分进程负责显示时间，下部分线程负责获取时间 synchronized关键字只是起到了多个线程“串行”执行临界区中代码的作用，但是哪个线程先执行，哪个线程后执行依无法确定，Object类中的wait()、notify()和notifyAll()三个方法解决了线程间的协作问题，通过这三个方法的“合理”使用可以确定多线程中线程的先后执行顺序： 1、wait()：对象锁调用了wait()方法会使当前持有该对象锁的线程处于线程等待状态同时该线程释放对对象锁的控制权，直到在其他线程中该对象锁调用noti
MFC多线程学习
weixin_43341380的博客
03-29 1053
MFC多线程学习 一、问题的提出 编写一个耗时的单线程程序： 新建一个基于对话框的应用程序SingleThread，在主对话框IDD_SINGLETHREAD_DIALOG添加一个按钮，ID为 IDC_SLEEP_SIX_SECOND，标题为“延时6秒”，添加按钮的响应函数，代码如下： void CSingleThreadDlg::OnSleepSixSecond() { Sleep(6000); //延时 6秒 } 编译并运行应用程序，单击“延时6秒”按钮，你就会发现
详述线程间数据共享
Gong_Zheng6的博客
02-06 147
线程中并发指一个时间段中多个线程都处于已启动但没有运行结束的状态。 多个线程之间默认并发运行，这种运行方式往往会出现交叉的情况。 package venus; public class Test { public static void main(String[] args) { new CounterThread("~~~~~~~~~~~~~~~").start(); new CounterThread("@@@@@@@@@@@@@@@").start();
【linux】多线程概念详述
qq_66314292的博客
03-18 1440
多线程的概念
【多线程】多线程之并发工具类
qq_34416331的博客
08-11 1456
一、概述 jdk 1.5 后，为我们提供的并发工具类有： 名称 描述 详细 CountDownLatch 同步计数器 初始化时，传入需要计数的线程等待数，并用 await() 阻塞当前线程，其他线程中可以调用countDown（）方法让计数器减一，当计数器为 0 时，则放行 CyclicBarrier 栅栏 让一组线程达到某个屏障被阻塞，一直到组内最后一个线程达到屏障时，屏障开放，所有被阻塞的线程才会继续运行 Semaphore 信.
MFC多线程各种线程用法
热门推荐
徐丨若木
06-25 1万+
一、问题的提出    编写一个耗时的单线程程序：    　　新建一个基于对话框的应用程序SingleThread，在主对话框IDD_SINGLETHREAD_DIALOG添加一个按钮，ID为 IDC_SLEEP_SIX_SECOND，标题为“延时6秒”，添加按钮的响应函数，代码如下：     void CSingleThreadDlg::OnSleepSixSecond()     {    Sl...
Java中详述线程与进程
zzu957的博客
02-04 197
线程与进程 进程（process） 是指一个程序的一次执行过程。 线程（thread） 又称为轻量级进程，线程是一个程序中实现单一功能的一个指令序列，是一个程序的单个执行流，存在于进程中，是一个进程的一部分。 1、一个进程可以包含多个线程，而一个线程必须在一个进程之内运行；同一进程中的多个线程之间采用抢占式独立运行；进程结束，则线程跟着结束，如果一个进程没有可执行的线程，进程也结束； 2、线程有独立的执行堆栈、程序计数器和局部变量；但是没有独立的存储空间，而是和所属进程中的其它线程共享存储空间； 3、操作
Win32 多线程程序设计(侯捷译) 书和源码
06-29
《Win32多线程程序设计》是一本深入探讨Windows操作系统环境下多线程编程的经典著作，由著名技术翻译家侯捷先生译介。这本书详细介绍了如何在Win32 API下编写高效、稳定的多线程应用程序，是学习和提升Windows系统...
多线程聊天
12-13
【多线程聊天】是一种在计算机网络编程中常见的实现方式，尤其在构建聊天应用程序时，它能有效地提高系统的并发性能和用户体验。在这个【网络编程实验】中，我们使用了Socket编程来创建一个基于【B/S（浏览器/服务器...
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 345
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 437
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 237
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 609
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
iOS多线程编程实战指南
"该资源是一份iOS多线程编程指南，适合初级开发者参考学习，由Apple Inc.原著，谢业兰（老狼）翻译。文档介绍了多线程的基本概念、替代方法、线程支持机制、设计技巧、线程管理、RunLoop的使用等内容，旨在帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值