多线程

最新推荐文章于 2024-12-01 23:53:39 发布
最新推荐文章于 2024-12-01 23:53:39 发布
阅读量210 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 互联网并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Ada_yangyang/article/details/81906095

一、主要内容

1. 线程的概念模型

2. 线程的创建和启动

3. 临界资源、对象锁

4. 线程的互斥和同步

二、程序、进程与多任务

程序（program）是对数据描述与操作的代码的集合，是应用程序执行的脚本。

进程（process）是程序的一次执行过程，是系统运行程序的基本单位。程序是静态的，进程是动态的。系统运行一个程序即是一个进程从创建、运行到消亡的过程。

多任务（multi task）在一个系统中可以同时运行多个程序，即有多个独立运行的任务，每个任务对应一个进程。

线程（thread）：比进程更小的运行单元，是程序中单个程序的流控制。一个进程中可以包含多个线程。

简单来讲，线程是一个独立的执行流，是进程内部的一个独立执行单元，相当于一个子程序。

一个进程中的所有线程都在该进程的虚拟地址空间中，使用该进程的全局变量和系统资源。

操作系统给每个线程分配不同的CPU时间片，在某一时刻，CPU只执行一个时间片内的线程，多个时间片中的相应线程在CPU内轮流执行。

三、创建多线程

1.  每个java程序启动后，虚拟机将自动创建一个主线程。

2. 可以通过以下两种方式自定义线程类：

1）创建java.lang.Thread类的子类，重写该类的run方法

2）创建java.lang.Runnable接口的实现类，实现接口中的run方法

四、继承Thread类

Thread：代表一个线程类

构造方法含义
Thread()创建一个新的线程对象
Thread(Runnable target)基于Runnable接口实现类的实例创建一个线程对象
Thread(Runnable t, String name)基于给定的Runnable接口实现类的实例和指定名字创建一个线程对象
Thread(String name)基于给定的名称创建一个线程对象

Thread类中的重要方法：

- run方法：包括线程运行时执行的代码，通常在子类中重写它。

- start方法：启动一个新的线程，然后虚拟机调用新线程的run方法。

package com.sgg.thread;

public class FirstThread extends Thread {

	public static void main(String[] args) {
		SecondThread t1 = new SecondThread();
		t1.start();
		for (int num = 0; num < 100; num++) {
			System.out.println(Thread.currentThread().getName() + ":" + num);
		}
	}
}

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

}

执行结果：两个线程交替执行，分别打印各自线程名，并各自把num从0加到100。

package com.sgg.thread;

public class FirstThread extends Thread {

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

	public static void main(String[] args) {
		FirstThread t1 = new FirstThread();
		t1.start();
		for (int num = 0; num < 100; num++) {
			System.out.println(Thread.currentThread().getName() + ":" + num);
		}
	}
}

执行结果：两个线程交替执行，分别打印各自线程名，并各自把num从0加到100。

package com.sgg.thread;

public class FirstThread extends Thread {
	
	public FirstThread(String name) {
		super(name);
	}

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

	public static void main(String[] args) {
		FirstThread t1 = new FirstThread("t1");
		t1.start();
		for (int num = 0; num < 100; num++) {
			System.out.println(Thread.currentThread().getName() + ":" + num);
		}
	}
}

创建两个线程，共同打印0-99。两个线程共享一个变量。

方法一：共享一个变量，static修饰变量

package com.sgg.thread;

public class PrintNumStatic {

	public static void main(String[] args) {
		PrintN t1 = new PrintN("线程1");
		PrintN t2 = new PrintN("线程2");
		
		t1.start();
		t2.start();
	}
}

class PrintN extends Thread{
	private static int i = 0;
	public PrintN(String name) {
		super(name);
	}
	@Override
	public void run() {
		for(;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

方法二：两个线程共享一个对象

package com.sgg.thread;

public class PrintNum extends Thread {
	private int num = 0;
	
	@Override
	public void run() {
		for(num = 0; num < 100; num++) {
			System.out.println(Thread.currentThread().getName() + ":" + num);
		}
	}
	
	public static void main(String[] args) {
		PrintNum pn = new PrintNum();
		Thread t1 = new Thread(pn, "t1");
		Thread t2 = new Thread(pn, "t2");
		t1.start();
		t2.start();
	}
	
}

五、执行流程图

package com.sgg.thread;

public class MyThreadDemo extends Thread{
	
	public MyThreadDemo(String name) {
		super(name);
	}
	//重写父类的run方法
	@Override
	public void run() {
		for(int i = 1; i<=10; i++) {
			System.out.println("当前线程"+getName()+"正在打印"+i);
		}
	}
	
	public static void main(String[] args) {
		//获取当前线程的名字
		String name = Thread.currentThread().getName();
		System.out.println(name + "开始执行!");
		
		//创建线程对象
		MyThreadDemo thread0 = new MyThreadDemo("thread0");
		MyThreadDemo thread1 = new MyThreadDemo("thread1");
		
		//启动线程
		thread0.start();
		thread1.start();
		
		for(int i = 1; i<=10; i++) {
			System.out.println("当前线程" + name + "正在打印" + i);
		}
		
		System.out.println(name + "执行完毕！");
	}
}

六、Runnable接口

1. Runnable接口中只有一个未实现的run方法，实现该接口的类必须重写该方法。

2. Runnable接口与Thread类之间的区别

1）Runnable接口必须实现run方法，而Thread类中的run方法是一个空方法，可以不重写

2）Runnable接口的实现类并不是真的线程类，只是线程运行的目标类。要想以线程的方式执行run方法，必须依靠Thread类

3）Runnable接口适合于资源的共享

package com.sgg.thread;

public class NewMyRunnableDouble implements Runnable{

	@Override
	public void run() {
		for(int i = 1; i <= 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}

	public static void main(String[] args) {
		NewMyRunnableDouble mrd = new NewMyRunnableDouble();
		
		Thread thread1 = new Thread(mrd, "thread1");
		Thread thread2 = new Thread(mrd, "thread2");
		
		thread1.start();
		thread2.start();
	}
}

执行结果：两个线程无规律交替执行，分别各自打印1-10

package com.sgg.thread;

public class MyRunnableSingle implements Runnable{

	private int i = 1;
	@Override
	public void run() {
		for(; i<= 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
	
	public static void main(String[] args) {
		MyRunnableSingle mrs = new MyRunnableSingle();
		Thread thread1 = new Thread(mrs);
		Thread thread2 = new Thread(mrs);
		thread1.start();
		thread2.start();
	}
}

执行结果：两个线程交替执行，共同打印1-10。

package com.sgg.thread;

public class MyRunnable {
	private static int num;

	public static void main(String[] args) {
		MyRunnable mr = new MyRunnable();
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				for (; num < 10; num++) {
					System.out.println(Thread.currentThread().getName()+":"+num);
				}

			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				for (; num < 10; num++) {
					System.out.println(Thread.currentThread().getName()+":"+num);
				}

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

执行结果：两个线程交替执行，共同打印1-10。

七、线程的生命周期

线程的生命周期：线程从创建到启动，直到运行结束。

可以通过调用Thread类的相关方法影响线程的运行状态。

线程的运行状态

  • 新建（New）
  • 可执行（Runnable）
  • 运行（Running）
  • 阻塞（Blocking）
  • 死亡（Dead）

八、线程的生命周期状态图

九、线程的生命周期状态

1. 新建状态（New）

  • 当创建了一个Thread对象时，该对象就处于“新建状态”
  • 没有启动，因此无法运行

2. 可执行状态（Runnable）

  • 其他线程调用了处于新建状线程的start方法，该线程对象将转换到“可执行状态”
  • 线程拥有获得CPU控制权的机会，处在等待调度阶段。

3. 运行状态（Runnable）

  • 处在“可执行状态”的线程对象一旦获得了CPU控制权，就会转换到“执行状态”。
  • 在“执行状态”下，线程状态占用CPU时间片段，执行run方法中的代码。
  • 处在“执行状态”下的线程可以调用yield方法，该方法用于主动出让CPU控制权。线程对象出让控制权后回到“可执行状态”，重新等待调度。

4. 阻塞状态（Blocking）

  • 线程在“执行状态”下由于受某种条件的影响会被迫出让CPU控制权，进入“阻塞状态”。
  • 进入阻塞状态的三种情况：1、调用sleep方法   2、调用join方法   3、执行I/O操作

1）public void sleep(long millis)

Thread类的sleep方法用于让当前线程暂时休眠一段时间

参数millis的单位是毫秒

sleep举例：每隔1秒钟打印一次

package com.sgg.thread;

public class SleepThreadTest extends Thread{
	@Override
	public void run() {
		
		for(int i = 0; i < 10; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
	
	public static void main(String[] args) {
		SleepThreadTest stt = new SleepThreadTest();
		Thread t1 = new Thread(stt,"t1");
		t1.start();
	}
}

2）调用join方法（合并某个线程）

处在“执行状态”的线程如果调用了其他线程的join方法，将被挂起进入“阻塞状态”

目标线程执行完毕后才会解除阻塞，回到“可执行状态”

package com.sgg.thread;

public class JoinThreadTest extends Thread{

	@Override
	public void run() {
		for(int i = 0; i<10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
	
	public static void main(String[] args) {
		JoinThreadTest thread = new JoinThreadTest();
		thread.start();
		
		for(int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
			if(i == 5) {
				try {
					thread.join();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

执行结果：main线程的i=6,7,8,9一定是最后执行。

3）执行I/O操作

线程在执行过程中如果因为访问外部资源（等待用户键盘输入、访问网络）时发生了阻塞，也会导致当前线程进入“阻塞状态”。

5. 解除阻塞

1）睡眠状态超时

2）调用join后等待其他线程执行完毕

3）I/O操作执行完毕

4）调用阻塞线程的interrupt方法（线程睡眠时，调用该线程的interrupt方法会抛出InterruptedException）打断阻塞

package com.sgg.thread;

public class InterruptThreadTest extends Thread {

	@Override
	public void run() {
		for(int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
			if(i == 10) {
				try {
					Thread.sleep(1000000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	public static void main(String[] args) {
		InterruptThreadTest thread = new InterruptThreadTest();
		thread.start();
		thread.interrupt();
	}
}

运行结果：程序不会阻塞，但是会报一个运行时异常，java.lang.InterruptedException

6. 死亡状态（Dead）：处于“执行状态”的线程一旦从run方法返回（无论是正常退出还是抛出异常），就会进入“死亡状态”。

已经“死亡”的线程不能重新运行，否则会抛出IllegalThreadStateException

可以使用Thread类的isAlive方法判断线程是否活着

package com.sgg.thread;

public class IsAliveThreadTest extends Thread{

	@Override
	public void run() {
		for(int i = 0; i<100; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
	
	public static void main(String[] args) {
		IsAliveThreadTest thread = new IsAliveThreadTest();
		System.out.println(thread.isAlive());
		thread.start();
		System.out.println(thread.isAlive());
		try {
			thread.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(thread.isAlive());
	}
}

执行结果：

false

true

for循环打印输出

false

十、线程调度

1. 线程调度

  • 按照特定机制为线程分配CPU时间片段的行为
  • java程序运行时，由java虚拟机负责线程的调度

2. 线程调度的实现方式

  • 分时调度模型：让所有线程轮流获得CPU的控制权，并且为每个线程平均分配CPU时间片段
  • 抢占式调度模型：选择优先级相对较高的线程执行，如果所有线程的优先级相同，则随机选择一个线程执行。Java虚拟机采用此种调度模型。

十一、线程的优先级

1. Thread类提供了获取和设置线程优先级的方法

  • getPriority：获取当前线程的优先级
  • setPriority：设置当前线程的优先级

2. java语言为线程类设置了10个优先级，分别使用1-10内的整数表示，整数值越大代表优先级越高。每个线程都有一个默认的优先级，主线程的默认优先级是5。

  • MAX_PRIORITY：代表了最高优先级10
  • MIN_PRIORITY：代表了最低优先级1
  • NORM_PRIORITY：代表了正常优先级5

3. setPriority不一定起作用，在不同的操作系统，不同的JVM上，效果也可能不同。操作系统也不能保证设置了优先级的线程就一定会先运行或得到更多的CPU事件。

4. 在实际使用中，不建议使用该方法。

 

 

 

 

 

 

 

 

 

 

 

python3多线程实战（python3经典编程案例）
数据知道的博客
08-25 8万+
总结： python多线程适用在I/O密集型的任务中。对于I/O密集型任务来说，较少的时间用在cpu计算上，较多的时间用在I/O上，如文件读写，web请求，数据库请求等； 对于计算密集型任务，应该使用多进程。 一. 多线程任务对比 线程也是轻量级进程，是操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程的实际运作单位 一个线程可以创建和撤销另一个线程，同一进程的多个线程之间可以并发执行。 线程有就绪，阻塞，运行3中基本状态。 计算密集型任务-多进程 from multiprocessing i
多线程之互斥、同步方法解析
yangjian1156的博客
05-11 521
本文阐述了多线程中存在安全问题的解决办法———互斥 同步。在使用过程中，互斥占用系统资源较大，所以建议使用同步
多线程编程之互斥
weixin_34227447的博客
04-21 158
一.互斥量（mutex）多个线程同时访问共享数据时可能会冲突。比如某个线程把某个全局变量增加1，这个操作在某平台需要三条指令完成：（1）从内存读变量值到寄存器； （2）寄存器的值加1；（3）将寄存器的值写会内存。假设两个线程在多处理器平台上同时执行这三条指令，则可能导致最后变量只加了1次，而不是2次。 程序如下： 1 #i...
Linux — 多线程的互斥与同步，信号量
一个努力拼搏的人
05-01 1827
条件变量是pthread库提供的一个数据类型，每当有线程访问临界资源时，申请互斥锁不成功，如果没有条件变量就会被阻塞挂起，有条件变量的话，就会通过一个接口将线程的PCB链接到条件变量里的队列中进行等待，上一个线程访问完临界资源后，它再想继续访问临界资源，对不起，要去条件队列里等待，此时会调用接口唤醒条件队列中的第一个线程，让他进行访问。可是呢，我们无法在加锁之前就得知此次访问是否满足条件，这样的话就会造成不管满不满足条件，都要先加锁，然后检测，满足就挂起，这样线程啥也没干，转了一圈，还浪费时间。
linux多线程实验实验报告,实验七 Linux多线程互斥
weixin_42399078的博客
05-06 723
实验目的:通过实验掌握下列知识:1、在Linux环境下，掌握pthread库中的mutex对象，pthread_mutex_lock()函数，pthread_mutex_init和pthread_self()的用法。2、在Linux环境下，掌握pthread_create()函数，pthread_join()函数的用法。3、在Linux环境下，掌握pthread_cancel(pthread_tt...
多线程编程实验
半濠春水的博客
05-06 2758
（一）查看下列程序并运行，掌握如何通过扩展Thread类创建线程。 package case1; public class MySimpleThread extends Thread { public void run() { for (int i = 0; i < 5; i++) { for (int j = 0; j < 8; j++) { System.out.print(getName() + "[" .
C++11 多线程（std::thread）详解
jcShan709的博客
07-17 14万+
注：此教程以 Visual Studio 2019 Version 16.10.3 （MSVC 19.29.30038.1) 为标准 文章目录线程？进程？多线程？什么是多线程？进程与线程的区别C++11的std::threadstd::thread常用成员函数构造&析构函数常用成员函数举个栗子例一：thread的基本使用例二：thread执行有参数的函数例三：thread执行带有引用参数的函数注意事项（剩下的内容还没写完，明天再更） 线程？进程？多线程？ 什么是多线程？ 百度百科中的解释： 多.
C++多线程
weixin_43229348的博客
04-17 3432
1.基础知识 为了提高CPU的使用率，将某些需要耗时较多的任务或是大量IO操作（IO处理速度很慢），采用多线程可以适当的提高程序的执行效率。 C++11之后有了std::thread库，需要引入头文件： 先来介绍Thread的成员函数： # 用来查看当前线程的id thread::get_id() # 检查此线程是否还和主线程连接（已经完成join、detach的线程都是false） thread：：joinable() # 将线程与主线程的连接切断，并且此线程会继续独立执行下去，直到执行结束时候释放分配的
Redis6 多线程模型
程序猿进阶
09-25 2350
线程，都同时处理图中的“队列”，是不是会存在锁竞争的关系尼？还需要注意的是，线程数并不是越大越好，官方认为超过了。,并对数据进行协议解析，当队列全部处理完毕后，主线程会对队列中请求串行“执行。官方建议：只在机器至少有4个内核时才启用多线程模型，且至少留下一个备用内核。【6】主线程执行所有命令并清空整个等待队列，等待客户端后续的请求队列；件事情串行一起执行，因为是基于内存，所以执行速度非常快。开启多线程后，还需要设置线程数，否则是不生效的。和串行操作，某个操作“出问题”会“阻塞”后续操作。
Java多线程实战-CountDownLatch模拟压测实现
热门推荐
qq_35716689的博客
03-17 25万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
高校智慧消防解决方案23P.pdf
最新发布
06-25
智慧消防解决方案
亚马逊的云计算平台AWS.ppt
06-25
亚马逊的云计算平台AWS.ppt
矿井智能物流系统关键技术研究与应用.docx
06-25
矿井智能物流系统关键技术研究与应用
感知器算法有代码.doc
06-25
感知器算法有代码.doc
微型计算机硬系统概要.ppt
06-25
微型计算机硬系统概要.ppt
QT多线程编程示例详解
标题“QT的多线程编程示例”指的是关于使用QT（一种跨平台的C++图形用户界面应用程序开发框架）进行多线程编程的示例。多线程是编程中一种技术，允许一个程序同时执行两个或两个以上的部分，这些部分可以并行运行，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值