多线程的使用

已于 2023-07-01 00:47:42 修改
阅读量51 收藏
点赞数
分类专栏： 需求文档 文章标签： java jvm
于 2023-06-11 14:31:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74163755/article/details/131153104
版权
本文介绍了Java中的线程概念，包括程序、进程和线程的区别，以及单线程和多线程的执行。文章详细讲解了如何通过继承Thread类和实现Runnable接口创建线程，并展示了多线程执行的示例。接着，讨论了线程的终止、常用方法如start、sleep和interrupt。此外，还深入探讨了线程的同步机制，包括互斥锁和死锁问题，以及如何避免和解决死锁。最后提到了线程的生命周期和锁的释放情况。
摘要由CSDN通过智能技术生成

文章目录

相关概念

  • 程序：是为完成特定任务，用某种语言编写的一组指令的集合
  • 进程：是程序的一次执行过程；是动态的，有它自身的产生，存在和消亡过程
  • 线程：由进程创建，是进程的一个实体；一个进程可以拥有多个线程
  • 单线程：同一个时刻，只允许执行一个线程
  • 多线程：同一个时刻，可以执行多个线程
  • 并发：同一个时刻。多个任务交替执行；单核cpu实现的多任务就是并发
  • 并行：同一个时刻，多个任务同时执行，多核cpu可以实现并行

基本使用

  • 创建线程的两种方式

    1. 继承Thread类，重写run方法

    2. 实现Runnable接口，重写run方法

      /**
*继承Thread类
*/
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
 
        cat.start();
    	for(int i = 0; i < 60; i++) {
        	System.out.println("主线程 i=" + i);
       
        	Thread.sleep(1000);
		}
	}
}


class Cat extends Thread {
	int times = 0;
	@Override
	public void run() {
        while (true) {
        //该线程每隔 1 秒。在控制台输出 “喵喵, 我是小猫咪”
        	System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
        try {
        	Thread.sleep(1000);
        } catch (InterruptedException e) {
        	e.printStackTrace();
        }
        if(times == 80) {
        	break;
        }
     }
}

      /**
*实现Runnable接口
*/
public class Thread02 {
	public static void main(String[] args) {
        Dog dog = new Dog();

        Thread thread = new Thread(dog);
        thread.start();

    }
}
class Animal {
}
class Tiger extends Animal implements Runnable {
	@Override
    public void run() {
    	System.out.println("老虎嗷嗷叫....");
    }
}

class ThreadProxy implements Runnable {
    private Runnable target = null;
    @Override
    public void run() {
    	if (target != null) {
    	target.run();
    	}
}
    public ThreadProxy(Runnable target) {
    	this.target = target;
    }
    public void start() {
    	start0();
    }
    public void start0() {
    	run();
    }
}
class Dog implements Runnable {
    int count = 0;
    @Override
    public void run() { 
        while (true) {
        	System.out.println("小狗汪汪叫..hi" + (++count) + 	Thread.currentThread().getName());
    		try {
            Thread.sleep(1000);
            } catch (InterruptedException e) {
            	e.printStackTrace();
            }
            if (count == 10) {
            	break;
            }
        }
    }
}

  • 多线程执行

    /**
*多线程执行
*/
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();

        }
class T1 implements Runnable {
        int count = 0;
        @Override
        public void run() {
        while (true) {
            //每隔 1 秒输出 “hello,world”,输出 10 次
            System.out.println("hello,world " + (++count));
            try {
            	Thread.sleep(1000);
            } catch (InterruptedException e) {
            	e.printStackTrace();
            }
            if(count == 60) {
            	break;
            }
        }
    }
}
class T2 implements Runnable {
        int count = 0;
        @Override
        public void run() {
        //每隔 1 秒输出 “hi”,输出 5 次
        while (true) {
            System.out.println("hi " + (++count));
            try {
            	Thread.sleep(1000);
            } catch (InterruptedException e) {
            	e.printStackTrace();
            }
            if(count == 50) {
            	break;
            }
        }
    }
}

    Thread vs Runnable

    1. 从创建线程来看，本质上无区别，Thread类本身就实现了Runnable接口
    2. 实现Runnable接口方式更加适合多个线程共享一个资源的情况，避免了单继承的限制，建议使用Runnable

线程终止

  1. 当线程完成任务后，会自动退出
  2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

线程常用方法

  • 常用方法①

    1. setName //设置线程名称，使之与参数 name相同
    2. getName//返回该线程的名称
    3. start //使该线程开始执行；Java虚拟机底层调用该线程的 start0 方法
    4. run //调用线程对象 run 方法；
    5. setPriority//更改线程的优先级
    6. getPriority//获取线程的优先级
    7. sleep//在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
    8. interrupt //中断线程

  • 注意事项和细节

  1. start 底层会创建新的线程，调用run,run 就是一个简单的方法调用，不会启动新线程
  2. 线程优先级的范围
  3. interrupt,中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
  4. sleep:线程的静态方法，使当前线程休眠

  • 常用方法②

    1. 1.yield:线程的礼让。让出cpu,让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功

    2. join:线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

      案例：main线程创建一个子线程，每隔1s 输出 hello,输出20次，主线程每隔1秒，输出 hi,输出 20次．要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。

/**
*使用案例
*/
public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Thread t3 = new Thread(new T3());
        for (int i = 1; i <= 10; i++) {
        System.out.println("hi " + i);
        if(i == 5) {
        	t3.start();
        }
        Thread.sleep(1000);
        }
    }
}
class T3 implements Runnable {
        private int count = 0;
        @Override
        public void run() {
        	while (true) {
        		System.out.println("hello " + (++count));
        	try {
        		Thread.sleep(1000);
        	} catch (InterruptedException e) {
        		e.printStackTrace();
        	}
            if (count == 10) {
            	break;
            }
        }
     }
}

  • 用户线程和守护线程

    1.用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
    2.守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
    3.常见的守护线程：垃圾回收机制

线程的生命周期

/**
*用程序查看线程状态
*/
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();
        while (Thread.State.TERMINATED != t.getState()) {
        	System.out.println(t.getName() + " 状态 " + t.getState());
        	Thread.sleep(500);
        }
        	System.out.println(t.getName() + " 状态 " + t.getState());
    }
}
class T extends Thread {
        @Override
        public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i);
                try {
                	Thread.sleep(1000);
                } catch (InterruptedException e) {
                	e.printStackTrace();
                }
                }
                break;
        	}
        }
}

线程的同步

  • Synchronized

    线程同步机制

    1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技

      术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。

    2. 也可以这里理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不

      可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地

      址进行操作

  • 同步具体方法

    1. 同步代码块

      synchronized(对象）｛ //得到对象的锁，才能操作同步代码

      ​ //需要被同步代码；

      ｝

    2. synchronized还可以放在方法声明中，表示整个方法－为同步方法

      public synchronized void m (String name){

      ​ //需要被同步的代码

      ｛

互斥锁

  1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
  3. 关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性：导致程序的执行效率要降低
  5. 同步方法（非静态的）的锁可以是this,也可以是其他对象（要求是同一个对象）
  6. 同步方法（静态的）的锁为当前类本身。
/**
*使用互斥锁解决售票问题
*/
public class SellTicket {
    public static void main(String[] args) {

        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
    }
}	

class SellTicket03 implements Runnable {
    private int ticketNum = 100;
    private boolean loop = true;
    Object object = new Object();

    synchronized (SellTicket03.class) {
    System.out.println("m2");
    }
    */
    public synchronized static void m1() {
    }
    public static void m2() {
    	synchronized (SellTicket03.class) {
    	System.out.println("m2");
    }
    }

    public /*synchronized*/ void sell() { 
        synchronized (/*this*/ object) {
        if (ticketNum <= 0) {
            System.out.println("售票结束...");
            loop = false;
            return;
        }
    
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
        }
    }
    @Override
    public void run() {
    	while (loop) {
    		sell();
    	}
    }
}

class SellTicket01 extends Thread {
    private static int ticketNum = 100;
        
        @Override
        public void run() {
        	while (true) {
                if (ticketNum <= 0) {
                	System.out.println("售票结束...");
                	break;
                }
             
                try {
                	Thread.sleep(50);
                } catch (InterruptedException e) {
                	e.printStackTrace();
                }
                System.out.println("窗口 " + 	Thread.currentThread().getName() + " 售出一张票" + " 剩余票数=" + (--ticketNum));
            }
        }
}
        
class SellTicket02 implements Runnable {
        private int ticketNum = 100;
        @Override
        public void run() {
            while (true) {
                if (ticketNum <= 0) {
                	System.out.println("售票结束...");
                break;
        	}
        
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
            	e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
            }
        }
}

注意事项和细节

  1. 同步方法如果没有使用static修饰：默认锁对象为this
  2. 如果方法使用static修饰，默认锁对象：当前类．class
  3. 实现的落地步骤：
    需要先分析上锁的代码
    ·选择同步代码块或同步方法
    要求多个线程的锁对象为同一个即可！

线程的死锁

/**
*线程的死锁
*/
public class DeadLock_ {
    public static void main(String[] args) {
       
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A 线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B 线程");
        A.start();
        B.start();
    }
}

class DeadLockDemo extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;
    public DeadLockDemo(boolean flag) {
    this.flag = flag;
    }
    @Override
    public void run() {
      
        if (flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + " 进入 1");
                synchronized (o2) { 
                System.out.println(Thread.currentThread().getName() + " 进入 2");
                }
        	}
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入 3");
                synchronized (o1) { 
            		System.out.println(Thread.currentThread().getName() + " 进入 4");
        		}
        	}
        }
    }
}

释放锁

  • 下面操作会释放锁

    1. 当前线程的同步方法、向步代的款测

      案例：上厕所，完事出来

    2. 当前线程在同步代码块、同步方法中遇到break、return.

      案例：没有正常的完事，经理叫他修改bug,不得已出来

    3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束

      案例：没有正常的完事，发现忘带纸，不得已出来

    4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并放锁。

      案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

  • 下面操作不会释放锁

    1. 线程执行同步代码块或同步方法时，程序调用Thread,sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁

      案例：上厕所，太困了，在坑位上眯了一会

    2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。

      提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

Rillia
关注
专栏目录
java多线程 注意事项_多线程使用及注意事项
weixin_30965253的博客
03-08 2735
1、并行和并发的区别2、多线程(高并发编程)的优点3、多线程程序需要注意事项4、线程的启动与安全中止5、怎么安全中止线程(interrupt())并行和并发的区别：一个是同时执行，一个是交替执行(线程切换)。例：把线程比做高速公路，如果有条高速公路并排有8条车道,那么最大的并行车辆就是8辆，只要车辆<=8，车辆就可以并行运行。单位时间内通过的车辆，就是并发。多线程(高并发编程)的优点：(1)...
多线程使用场景及总结
gaoyun1997的博客
11-05 3362
为什么要使用多线程？ 1.防止阻塞主线程,提高吞吐量： 你做WEB，容器帮你做了多线程，但是他只能帮你做请求层面的。简单的说，可能就是一个请求一个线程。或多个请求一个线 程。如果是单线程，那同时只能处理一个用户的请求。 2,提高资源的利用率 应用场景: 1,最典型的应用比如tomcat，tomcat内部采用的就是多线程，上百个客户端访问同一个web应用，tomcat接入后都是把后续的处理扔给一个新的线程来处理，这个新的线程最后调用到我们的servlet程序，比如doGet或者doP...
java多线程使用详解与案例，超详细
languageStudent的博客
03-14 3万+
java多线程使用 java使用多线程的三种方式： 继承Thread类，并重写run方法。 实现Runnable接口，重写run方法 实现Callable<返回值>接口，重写call方法 实例如下 继承Thread class test extends Thread{ @Override public void run() { System.out.println("你好啊"); } } 开始启动线程： new test().start() 实现R
电商项目中的多线程使用经验
xwl_java的博客
08-26 1万+
是否使用多线程是看实际场景，跟架构没多大关系。比如你用ssh做电商网站 ，肯定要考虑多线程问题，如果用ssh做一般的管理应用系统，并发量不是很大，就不需要多线程。 并不是说采用ssh的项目，框架自动就帮你弄好多线程了，那是不可能的。 场景一:一个业务逻辑有很多次的循环，每次循环之间没有影响，比如验证1万条url路径是否存在，正常情况要循环1万次，逐个去验证每一条URL，这样效率会很低，假设验...
Python多线程使用详解
Rocky006的博客
07-11 7873
多线程是一种并发编程的技术，通过同时执行多个线程来提高程序的性能和效率。在Python中，我们可以使用内置的threading模块来实现多线程编程。
Spring中的多线程使用(使用线程池 ThreadPoolTaskExecutor, CompletableFuture)
知北行的博客
12-17 4014
SpringBoot应用中需要添加@EnableAsync注解，来开启异步调用，一般还会配置一个线程池，异步的方法交给特定的线程池完成， 1. 配置线程池 添加一个Configuration类, 代码如下: @Configuration @EnableAsync public class ThreadConfig { @Bean("doSomethingExecutor") public Executor doSomethingExecutor() { ThreadPool
一文详解C++多线程
热门推荐
非晚非晚的博客
04-25 8万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
多线程使用场景(经典必看)
qq_41246635的博客
10-08 2515
为什么要使用多线程? 1.防止阻塞主线程,提高吞吐量：     你做WEB，容器帮你做了多线程，但是他只能帮你做请求层面的。简单的说，可能就是一个请求一个线程。或多个请求一个线         程。如果是单线程，那同时只能处理一个用户的请求。 2,提高资源的利用率 应用场景: 1,最典型的应用比如tomcat，tomcat内部采用的就是多线程，上百个客户端访问同一个web应用，tomca...
python fastAPI 多线程使用
m0_37684144的博客
11-20 3969
python fastAPI 多线程使用
AtomicBoolean多线程的使用
Lovincc的博客
07-16 6223
作用 在公司的一套自己开发的系统中，发现有这么一个东西，经过查阅资料，api，大概了解到这个东西，是为了保证在多个线程下，这个业务只有一个线程进行处理。 与普通的多线程来比较public class Aomication implements Runnable{ private static boolean exits = false; private String name;
C# Timer的多线程使用方法
03-29
多线程使用时的注意事项： - **线程安全**：无论是哪种Timer，当在回调或事件处理程序中访问共享数据或UI控件时，都需要确保线程安全。使用`lock`关键字、`Monitor`类或.NET的线程同步机制（如`Interlocked`）来防止...
python关于多线程使用全局变量的问题
weixin_44840774的博客
12-18 2720
python关于多线程使用全局变量的问题 在多线程中，如果多线程同时对一个全局变量进行操作时，就有可能出现异常，比如下面的程序： # -*- coding:UTF-8 -*- import threading import time #定义一个全局变量 g_num = 0 def test1(num): global g_num for i in range(num): g_num += 1 print(g_num) def test2(num): gl
JAVA多线程使用场景与安全注意事项
以下是对Java多线程使用场景的深入探讨以及使用多线程时需要注意的事项。 **一、Java多线程的使用场景** 1. **网络服务** - 在服务器端，为了处理来自不同客户端的并发请求，通常会使用多线程技术。每个线程处理一...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 227
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 286
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 909
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Backend - Java 基础
是萝卜干呀的博客
10-11 834
知识量决定了未来能走多远
JavaWeb Servlet--09深入：注册系统04--修改页面
最新发布
weixin_62189092的博客
10-16 172
这里就会获取要修改的用户的id，返回用户，再把这个用户重定向跳转到update.jsp页面。在再UserServlet里书写修改的代码。分析：点击修改超链接，就跳转到一个修改界面，要显示原本的数据，且密码显示出来，在该页面将对用户的数据的进行修改，最后提交。findUserByID()----显示原本的内容，update()---修改数据库内容的方法。注意：修改信息是要展示密码的文本内容，所以在password处type="text";写法和register没有太大的区别，主要是对文本框获得值。
JavaSE——认识异常
wx2023_10_15的博客
10-12 960
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值