多线程

最新推荐文章于 2024-11-30 15:38:14 发布
原创 最新推荐文章于 2024-11-30 15:38:14 发布 · 124 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#多线程

多线程

进程和线程的概念和区别

  • 进程: 应用程序的执行实列,有独立的内存空间和系统资源
  • 线程: CPU调度和分配的基本单位,进程中执行最小的单位,可完成一个独立的顺序控制流程.

多线程

  • 一个进程中同时运行了多个线程,用来完成不同的工作,则称之为多线程.
  • 多线程交替占用CPU资源,而非真正的并行执行
  • 好处:
      1. 充分利用CPU的资源.
    • 简化编程模型.
    • 带来良好的用户体验
主线程
  • main() 即为主线程入口.
  • 产生其他子线程的线程
  • 必须最后完成执行,因为它执行各种关闭动作.
创建线程的两种方式:
  1. 继承Thread 类. 重写run方法.
    1. 实例化编写类对象, 调用 start()方法 开启线程.
/**
 *  编写 MyThread类 继承 Thread类的方式创建线程.
 * @author MateBook
 *
 */
public class MyThread extends Thread{
	
	// 重写run()方法
	public void run() {
		for(int i = 0 ; i <100 ; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
	
}

public class MyThreadTest {

	public static void main(String[] args) {

		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		// start() 启动线程.
		t1.start();	// 实现了多线程.交替执行.
		t2.start();	// 交替执行.系统cpu随机分配时间段.从0开始依次执行到循环结束.

//		t1.run();
//		t2.run();	// 1. 只有主线程一条执行路径.   2.依次调用了2次run方法.
	}
}
  1. 实现Runnable接口 重写run方法
    1. 实例化实现类, 实例化 Thread类,
    2. 将实现类作为 Thread构造的参数. 调用 strat() 方法 开启线程.
package com.thread;

/**
 *  实现 Runnable接口的方式创建线程.
 * @author MateBook
 *
 */
public class MyRunnable implements Runnable {

	public void run() {
		for(int i = 0 ; i < 100 ; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
	
}

package com.thread;
	

/**
 *  
 * @author MateBook
 *					
 *
 *			创建线程的2种方式 :  
 *				1.  编写一个类,继承 Thread类.  重写 run 方法.  
 *						在测试类里实例化编写的类,调用 strat()方法.启动线程.
 *
 *				2.  编写一个类,实现 Runnable接口, 重写 run 方法. 
 *					实例化编写类, 再实例化 Thread 对象. 将实现的编写类, 作为 Thread构造参数.
 *					再调用 strat() 方法.启动线程.
 *
 */
public class MyRunnableTest {
	
	public static void main(String[] args) {
		
		// 1. 创建线程对象
		MyRunnable t1 = new MyRunnable();
		Thread t = new Thread(t1);	// 将 Runnable实现类的对象传入 Thread带参构造里.
		Thread tt = new Thread(t1,"MyBaby");// 再Thread 构造里修改线程名.
		
		// 2. 调用start() 方法启动线程.
		tt.start();
	}
}
比较两种创建线程的方法
  • 继承 Thread 类
    1. 编写简单,可直接操作线程.
    2. 适用于单继承.
  • 实现Runnable接口
    1. 避免单继承局限性
    2. 便于共享资源

线程的状态

线程的5种状态分为

  1. 新建状态
  2. 就绪状态
  3. 运行状态
  4. 堵塞状态
  5. 死亡状态
package com.threadDemo4;

public class MyRunnable implements Runnable{

	public void run() {
		System.out.println("线程A正在运行");		// 运行状态
		try {
			Thread.sleep(500);// 线程休眠sleep(毫秒数)
			System.out.println("线程A休眠,处于阻塞状态!"); // 堵塞状态(休眠状态)
		} catch (InterruptedException e) {
			e.printStackTrace();
			System.out.println("线程A被中断!");	// 死亡状态.
		}
	}
	
	public static void main(String[] args) {
		
		Thread t = new Thread(new MyRunnable(),"A");
		System.out.println("线程A处于新建状态");	// 新建状态
		t.start();
		System.out.println("线程A处于就绪状态"); // 就绪状态.
	}
}

线程的优先级

  1. 线程的优先级由 1~10表示, 1最低. 默认优先级为 5.
  2. setPriority() 设置优先级 将静态常量作为参数. 如:
    1. Thread.Max_Priority (表示最大优先级) 10
    2. Thread.Min_Priority (表示最小优先级.) 1
package com.threadDemo5;

public class MyRunnable implements Runnable{
			//  实现接口 重写 run方法.
	public void run() {
		for(int i = 0 ; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
	
}


package com.threadDemo5;
/**
 *  设置线程的优先级.
 * @author MateBook
 *
 */
public class MyRannableTest {

	public static void main(String[] args) {
		
		Thread t1 = new Thread(new MyRunnable(),"BabyA");
		Thread t2 = new Thread(new MyRunnable(),"BabyB");
		t1.setPriority(Thread.MAX_PRIORITY); // 设置线程优先级   10
		t2.setPriority(Thread.MIN_PRIORITY); //  1 
		
		// 开启线程
		t1.start();
		t2.start();
	}

}

线程休眠

  1. 静态方法: public static void sleep(long millis)
    1. millis 为休眠时长, 以毫秒为单位.
    2. 调用sleep() 方法需要处理 InterruptedException 异常
  2. 让线程暂时睡眠指定时长,线程进入阻塞状态.
  3. 睡眠时间过后线程会在进入可运行状态.
package com.threadDemo6;
/**
 * 
 * @author MateBook
 *	实现休眠
 */
public class Wait {
	
	// 编写一个静态方法
	public static void bySec(long s) {	// 参数为long类型. 
		for(int i = 0 ; i < s;i++) {	// for循环遍历. 将传进来的参数作为 判断条件.
			System.out.println(i+1+"秒"); //  每循环依次输出
			try {
				Thread.sleep(1000);		// 设置休眠时间. 1000 毫秒 = 1秒. 捕获异常.
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
package com.threadDemo6;

/**
 *  主线程休眠5秒.
 * @author MateBook
 *
 */
public class Test {
	
	public static void main(String[] args) {
		System.out.println("主线程开始休眠");
		Wait.bySec(10); // 让主线程休眠10秒.
		System.out.println("主线程休眠结束");
		
	}
}

线程的强制运行

  1. 使当前线程暂停执行,等待其他线程执行结束后再继续执行本线程.
    1. 方法
    2. public final void join()
    3. public final void join(long mills)
    4. public final void join(long mills,int nanos).
      1. mills:以毫秒为单位的等待时长,
      2. nanos:要等待的附加纳秒时长.
      3. 需要处理 InterruptedException 异常.
package com.threadDemo7;

public class MyRunnable implements Runnable{
	//  实现Runnable 接口,  重写 run方法.
	public void run() {
		
		for(int i = 0 ; i < 10 ; i++) {
			try {
				Thread.sleep(100); // 每循环依次休眠100毫秒.
			} catch (InterruptedException e) {
				e.printStackTrace();
			}// 输出信息.
			System.out.println(Thread.currentThread().getName()+"运行."+i);
		}
	}

}

package com.threadDemo7;
/**
 *  测试 join()方法.
 * @author MateBook
 *
 */
public class ThreadJoinDemo {
	
	public static void main(String[] args) {
			
		System.out.println("线程强制执行");
		// 1 创建线程对象.并命名.
		Thread temp = new Thread(new MyRunnable(),"temp");
		// 开启线程.
		temp.start();
		
		for(int i = 0 ; i < 20;i++) {
			// 当主线程执行到 i = 5的时候.暂停主线程, 让子线程 temp执行完毕之后 主线程再执行.
			if(i==5) {
				try {
					temp.join();// 强制执行. 执行结束后 主线程再接着执行.
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			try {
				Thread.sleep(100); // 每循环依次休眠100毫秒.
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			// 输出提示.
			System.out.println(Thread.currentThread().getName()+"运行,"+i);
			
		}
	}
}

线程的礼让

  1. 暂停当前线程,允许其他具有相同优先级的线程获得运行机会.
  2. 该线程处于就绪状态,不转为阻塞状态.
  3. 方法名:
    1. public static void yield()
    2. 注意: 只是提供一种可能,但是不能保证一定会实现礼让.
package com.threadDemo8;

public class MyRunnable implements Runnable{

	public void run() {
		
		for(int i = 0 ; i < 5 ; i++) {
			System.out.println(Thread.currentThread().getName()+"运行:"+i);
			
			// 当i == 3 时, 线程礼让. 当前线程将cpu资源让出.
			if(i==3) {
				Thread.yield();// 线程礼让. 静态方法可以类名.方法直接调.
				System.out.print("线程礼让:");
			}
			
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}
package com.threadDemo8;

/**
 *  测试线程礼让.
 * @author MateBook
 *
 */
public class Test {
	
	public static void main(String[] args) {
		// 创建2个线程.
		Thread t1 = new Thread(new MyRunnable(),"线程A");
		Thread t2 = new Thread(new MyRunnable(),"线程B");
		// 开启2个线程.
		t1.start();
		t2.start();
		
		
	}

}

线程同步方法和代码块

  1. 当两个或多个线程要同时访问同一资源时,需要以某种顺序来确保该资源在某一时刻只能被一个线程使用的方式称为线程同步.

  2. 采用同步来控制线程的执行由两种方式,即同步方法和同步代码块.这两种方法都是用 synchronized 关键字实现.

  3. 关键字 synchronized

    1. 应用在修饰符前或后都可以
    2. 使用 synchronized 定义一个静态方法, 代码如下.
    package com.sale1;
/**
 * 
 * @author MateBook
 *		
 *		模拟网站  使用同步方法.
 *
 *
 */
public class Site implements Runnable{
	
	private int count = 10;	// 记录剩余票数.
	private int num = 0; // 记录当前抢到第几张票.
	private boolean flag = false; // 记录票是否售完.
	
	public  void run() {
		// 循环 , 当剩余票数为0时,循环结束.
		
		while(!flag) {
			sale();		
		}
	}
	
	
	
	// 同步方法:售票
	public synchronized void sale() {
		if(count<=0) {
			flag = true;
			return;
		}
		// 修改票数.
		count--;
		num++;
		
		try {
			// 设置休眠.
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
			// 输出抢到的第几场票.和剩余的票数.
		System.out.println(Thread.currentThread().getName()+"抢到第"+num+"张票,剩余:"+count+"张票");
	}
	

}
    1. 使用 synchronized 代码块方法如下.
package com.sale2;

/**
 * 
 * @author MateBook
 * 
 *         模拟网站 使用同步代码块.
 *
 *
 */
public class Site implements Runnable {

	private int count = 10; // 记录剩余票数.
	private int num = 0; // 记录当前抢到第几张票.

	public void run() {
		// 循环 , 当剩余票数为0时,循环结束.

		while (true) { 
			synchronized (this) { // synchronized (this) 通常为this 需要同步的对象. 效果与同步方法相同.
				if (count <= 0) {
					break;
				}
				// 修改票数.
				count--;
				num++;

				try {
					// 设置休眠.
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// 输出抢到的第几场票.和剩余的票数.
				System.out.println(Thread.currentThread().getName() + "抢到第" + num + "张票,剩余:" + count + "张票");
			}
		}
	}
}
  1. 多个并发线程访问同一资源的同步代码时. (同步方法亦是如此.)
    1. 同一时刻只能有一个线程进入 synchronized(this) 同步代码块
    2. 当一个线程访问一个 synchronized(this)同步代码块时, 其他 synchronized(this)同步代码块同样被锁定.
    3. 当一个线程访问一个 synchronized(this) 同步代码块时,其他线程可以访问该资源的非 synchronized(this) 同步代码块.

线程安全的类型

方法是否同步效率比较适合场景
线程安全是低多线程并发共享资源
非线程安全否高单线程
  1. ArrayList 非线程安全.
  2. Hashtable 线程安全, 效率低 键和值不允许为 null.
  3. HashMap 非线程安全. 效率高. 键和值都允许为 null
  4. StringBuffer 线程安全. 效率低
  5. StringBuilder 非线程安全. 效率高.

死锁

什么是死锁.

  1. 两个线程都在等待对方先完成,造成程序停滞
  2. 死锁的条件
    1. 两个或两个以上的线程在活动.
    2. 某个线程拿到一个锁以后,还想拿到第二个锁,造成锁的嵌套.
  3. 如何避免死锁.
    1. 当前线程先释放自己的锁. 线程之间就能解锁.
    2. 尽量减少同步方法.同步代码块的嵌套.

线程池

  • 线程池所在的包是 java.util.concurrent

  • 顶级接口是 Executor, 真正的线程池接口是 ExecutorService

  • java.util.concurrent.Executors 类提供创建线程池的方法.

  • 不使用线程池

    • 线程缺乏统一管理,占用过多系统资源
    • 缺乏更多功能,如定期执行,定时执行等.

  • 使用线程池的好处.

    • 重用存在的线程,减少对象的创建,消亡和开销
    • 有效控制最大的并发数,提高系统资源使用率.
    • 定时执行,定期执行.
方法名说明
newCachedThreadPool()创建一个可缓存的线程池,有任务时才创建新任务
newSingleThreadExecutor()创建一个单线程池
newFixedThreadPool(int nThreads)创建一个固定长度的线程池,空闲线程会一直保留,参数nThreads设定线程池中的线程的数目
newScheduledThreadPool(int corePoolSize)创建一个谷固定长度的线程池,而且以延迟或定时的方式来执行任务.

ThreadPoolExecutor 类

构造器中各个参数的含义.

  • corePoolSize : 核心池的大小.
  • maximumPoolSize: 线程池最大线程数.
  • keepAliveTime: 表示线程没有执行任务时最多保持多久时间会终止.
  • unit: 参数 keepAliveTime 的时间单位.
  • workQueue: 一个阻塞队列. 用来存储等待执行的任务.
  • handler: 表示当拒绝处理任务时的策略.
libb1507
关注
多线程编程全攻略：提升性能与线程安全的必备知识
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
10-14 10万+
介绍多线程编程的相关概念、同步机制以及无锁编程。从线程的基础概念出发，包括逻辑线程和硬件线程的比较，以及线程、核心和函数的关系。随后，我们探讨了多线程编程的基本原则，包括时间分片、上下文切换、线程安全函数和可重入函数等。接着，我们讨论了为什么需要多线程同步、什么情况需要进行同步以及多线程同步的方式，包括串行化、原子操作和锁等。我们还深入研究了非阻塞的无锁同步机制，如CAS循环和无锁数据结构。最后，我们解释了程序序、内存序、乱序执行、存储缓冲区和失效队列等概念，以帮助更好地理解多线程编程。
异步处理优化：多线程线程池与消息队列的选择与应用
最新发布
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
12-01 169万+
本文讨论了两种常见的异步处理方式：多线程线程池和消息队列（MQ）。通过将非核心逻辑异步化，可以提升系统的性能和响应速度。多线程线程池适用于本地并发任务，适合需要快速响应的场景，但无法处理跨服务任务。消息队列则适用于分布式系统，能够解耦服务并保证任务的可靠性和顺序性，适合处理高并发和高可靠性要求的任务。文章提供了实际代码示例，帮助开发者根据业务需求选择合适的异步处理方式。
Java线程池面试题
程序员世杰
10-14 1029
一、什么是线程池？ 线程池是一种多线程处理形式，处理过程中将任务提交到线程池，任务的执行交由线程池来管理。 如果每个请求都创建一个线程去处理，那么服务器的资源很快就会被耗尽，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 二、为什么要使用线程池？ 创建线程和销毁线程的花销是比较大的，这些时间有可能比处理业务的时间还要长。这样频繁的创建线程和销毁线程，再加上...
多线程中的Join
柯基的博客
09-16 3122
线程中join(强制执行)：当前线程执行完毕之后，才会执行后面程序，其他线程阻塞； 实例： public class ThreadJoin implements Runnable{ @Override public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Join..."+i+"运行中"); } } public stat
Python多线程与多线程中join()的用法
weixin_30566149的博客
09-11 1436
Python多线程与多进程中join()方法的效果是相同的。 下面仅以多线程为例： 首先需要明确几个概念： 知识点一： 当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行流的最小单元，当设置多线程时，主线程会创建多个子线程，在python中，默认情况下（其实就是setDaemon(False)），主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束，例...
五种线程池的分类和作用
weixin_30780649的博客
07-17 1735
1、newCachedThreadPool 作用：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。 特征：（1）线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）（2）线程池中的线程可进行缓存重复利用和回收（回收默认时间为1分钟）（3）当线程池中，没有可用线程，会重新创建一...
QThread的用法
HuZhenXing
08-06 8万+
概述 QThread类提供了一个与平台无关的管理线程的方法。一个QThread对象管理一个线程。QThread的执行从run()函数的执行开始，在Qt自带的QThread类中，run()函数通过调用exec()函数来启动事件循环机制，并且在线程内部处理Qt的事件。在Qt中建立线程的主要目的就是为了用线程来处理那些耗时的后台操作，从而让主界面能及时响应用户的请求操作。下面就谈谈如何利用QT
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Spring @Async：SpringBoot 自定义线程池，修改springboot的默认线程池
z69183787的专栏
09-16 3023
1. 自定义线程池 1.1 修改application.properties task.pool.corePoolSize=20 task.pool.maxPoolSize=40 task.pool.keepAliveSeconds=300 task.pool.queueCapacity=50 1.2 线程池配置属性类TaskThreadPoolConfig .java import org.springframework.boot.context.properties.Configurat
线程池的分类
m0_59640751的博客
08-05 291
1、缓存线程池： * 当线程执行后，由于线程池里已经有缓存的相同线程了，再创建一个新的相同的，他会调用线程池里的来运行 * (长度无限制) * 任务加入后的执行流程 * 1、判断线程池是否存在空闲线程 * 2、存在则使用 * 3、不存在，则创建线程，并放入线程池，然后使用 2、定长线程池： * （长度是指定的数值） * 任务加入后的执行流程 * 1、判断线程池里是否存在空闲线程 * 2、存在则使用 * 3、不存在空闲线程，且线程未满的情况下，则创建线程池，然后使用 * 4、不存在空闲线程，且线程已
简单的python多线程实例
weixin_30780649的博客
06-17 422
今天抽时间又学了一下python的多线程，理解的又多了一些，为了利于理解，写了一段很简单的代码，如下： import threading from time import sleep def task1():　　　　　　#线程函数1 for i in range(0, 9): print("i am thread one !!") def t...
qt 等待线程结束_QT5线程关闭
weixin_33542015的博客
12-24 4658
QT5线程关闭QThread析构函数的说明:请注意，删除一个QThread对象不会停止它管理的线程的执行。 删除正在运行的QThread(即isFinished()返回false)将导致程序崩溃。 在删除QThread之前等待finished()信号。从Qt4.8起，可以释放运行刚刚结束的线程对象，通过连接finished()信号到QObject::deleteLater()。QThread类qu...
completablefuture 线程池_SpringBoot中如何优雅的使用多线程
weixin_39636099的博客
11-27 929
本文带你快速了解@Async注解的用法，包括异步方法无返回值、有返回值，最后总结了@Async注解失效的几个坑。在 SpringBoot 应用中，经常会遇到在一个接口中，同时做事情1，事情2，事情3，如果同步执行的话，则本次接口时间取决于事情1 2 3执行时间之和；如果三件事同时执行，则本次接口时间取决于事情1 2 3执行时间最长的那个，合理使用多线程，可以大大缩短接口时间。那么在 Spring...
Java高并发3-中断线程以及isInterrupted与interrupted区别
weixin_44630050的博客
10-31 649
一、复习上一节内容 wait()方法、中断正在运行的线程会抛出java.lang.InterruptedException、当线程调用共享对象的wait()方法时，当前线程只会释放当前共享变量的锁，不会释放该线程所持有的其他共享变量的锁。 wait(long timeout,int nanos）实现、wait(0)内部调用了wait()方法、notify()随机唤醒、notifyAll()全部唤醒、join方法、sleep方法、yield方法，以及sleep与yield方法的区别 二、线程中断inter
线程池的种类
Flying_Fish_roe的博客
11-30 1041
使用类创建线程池，允许精细化配置线程池参数。Java 提供了多种类型的线程池，包括固定线程池、缓存线程池、单线程池、调度线程池和自定义线程池。这些线程池在不同场景下适用，可以有效提高程序的性能并减少资源开销。在实际开发中，应根据任务特点选择合适的线程池类型，并注意线程池的管理和配置，以避免资源浪费或性能问题。
线程池类型
weixin_51315931的博客
02-05 3982
对于线程池的一个初步了解
QT多线程编程示例详解
标题“QT的多线程编程示例”指的是关于使用QT（一种跨平台的C++图形用户界面应用程序开发框架）进行多线程编程的示例。多线程是编程中一种技术，允许一个程序同时执行两个或两个以上的部分，这些部分可以并行运行，...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值