多线程

最新推荐文章于 2023-11-12 11:35:54 发布
最新推荐文章于 2023-11-12 11:35:54 发布
阅读量426 收藏 1
点赞数
分类专栏： 多线程 文章标签： 多线程 消费者与生产者
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DREAMEER_DD/article/details/55803179
版权
多线程机制

1.线程的基本概念

2.线程的创建

3.线程的调度和优先级

4.线程的状态控制

5.线程同步


1.1 线程的基本概念
1.1.1 线程是程序里不同的执行路径
2.1 线程的创建
        2.1.1 继承Thread类
        2.1.2 实现runnable接口（推荐使用）
3.1 线程的调度和优先级
      Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。
      线程调度器按照线程的优先级决定应调度那个线程来执行。
      优先级越高，获得的时间片长度越多。
      线程优先级用数字表示，范围从1到10，一个线程的缺省优先级是5。
      Thread.MIN_PRIORITY=1
      Thread.MAX_PRIORITY=10
      Thread.NORM_PRIORITY=5
     使用下述方法获得或设置线程对象的优先级
           int getPriority();

           void setPriority();


                 涉及优先级的demo(线程优先级越高，分配的时间片相对越长)：    

public class TestPriority {
    public static void main(String[] args) {
		Runnable runnable1=new T1();
		Runnable runnable2=new T2();
		Thread thread1=new Thread(runnable1);
		Thread thread2=new Thread(runnable2);
		thread1.setPriority(Thread.NORM_PRIORITY+3);
		thread1.start();
		thread2.start();
	}
}

class T1 implements Runnable{

	public void run() {
		for(int i=0;i<1000;i++){
			System.out.println("T1: "+i);
		}
	}
	
}

class T2 implements Runnable{

	public void run() {
		for(int i=0;i<1000;i++){
			System.out.println("T2: "+i);
		}
	}
	
}

4.1 线程状态控制

4.1.1 sleep()方法 (让当前线程休眠)(如何优雅地关掉一个线程 interrupt、stop、通过标志位【推荐】)        

import java.util.Date;

/*sleep用法*/
public class TestInterrupted {
	public static void main(String[] args) {
		Runnable thread = new Mythread1();// 创建线程
		Thread mythread=new Thread(thread);
		mythread.start();// 使线程处于就绪状态
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
		}
		mythread.interrupt();
	}
}

/*
 * 推荐使用--通过实现接口来实现Thread的创建 
 * 1.1 java里面只有单继承，这样线程类的灵活性更好
 */
class Mythread1 implements Runnable{
	public void run() {
		while(true) {
			System.out.println("---" + new Date() + "---");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// 捕捉到异常时退出
				return;
			}
		}
	}

}
              

                **如何优雅关闭一个线程：

public class TestThread1 {
	public static void main(String[] args) {
		Runner1 runner1=new Runner1();
		Thread thread=new Thread(runner1);
		thread.start();
		for(int i=0;i<100000;i++){
			if(i%10000==0&&i>0){
				System.out.println("in main thread i="+i);
			}
		}
		System.out.println("thread main is over");
		//thread.stop();  //不推荐使用stop()
		runner1.shutDown();
	}
}

class Runner1 implements Runnable{
	//如何地优雅关闭某个线程：实质就是优雅停止执行线程的方法体：run()

	private boolean flag=true;
	public void run() {
		int i=0;
		while(flag==true){
			System.out.println("i: "+i++);
		}
	}
	
	public void shutDown(){
		flag=false;
	}
	
}

4.1.2 join()方法  (合并某个线程)

public class TestJoin {
	public static void main(String[] args) {
		Runnable runnable=new Mythread2();
		Thread thread=new Thread(runnable);
		thread.setName("thread1");
		thread.start();
		try {
			thread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		for(int i=1;i<=10;i++){
			System.out.println("i am main thread");
		}
	}
    
}

class  Mythread2 implements Runnable{
	public void run() {
		for(int i=1;i<=10;i++){
			System.out.println("i am "+Thread.currentThread().getName());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}

4.1.3 yield()方法 (让出cpu,给其他线程执行的机会)

public class TestYield {
    public static void main(String[] args) {
		Runnable runnable=new MyThread3();
		Thread thread1=new Thread(runnable);
		Thread thread2=new Thread(runnable);
		thread1.start();
		thread2.start();
		for(int i=0;i<20;i++){
			System.out.println("mainThread"+": "+i);
			if(i%10==0){
				Thread.yield();
			}
		}
	}
}

class MyThread3 implements Runnable{

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

4.1.4 wait()方法 、notify()/notifyAll()方法(配对使用、前提：获得锁)

                        wait():     

           

                        notify():


                        经典的消费者生产者问题：

public class ProductComsumer {
  public static void main(String[] args) {
	SyncStack stack=new SyncStack();
	Producter producter=new Producter(stack);
	Comsumer comsumer=new Comsumer(stack);
	new Thread(producter).start();
	new Thread(comsumer).start();
}
}

//馒头类
class WoTou{
	private int id;
	public WoTou(int id){
		this.id=id;
	}
	public String toString(){
		return "WoTou : "+id;
	}
}
//蒸笼类
class SyncStack{
	private int index=0;
	private WoTou[] arrWT=new WoTou[6];
	
	//生产馒头
	public synchronized void push(WoTou wt){
		while(index==arrWT.length){
			try {
				this.wait();  //停止生产馒头
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify();     //通知消费馒头
		arrWT[index]=wt;
		index++;
	}
	//消费馒头
	public synchronized WoTou pop(){
		while(index==0){
			try {
				this.wait();  //停止消费馒头
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify();    //通知生产馒头
		index--;
		return arrWT[index];
	}
}
//生产者类
class Producter implements Runnable{
	
    private SyncStack stack=null;
    public Producter(SyncStack stack){
    	this.stack=stack;
    }
	public void run() {
		WoTou woTou=null;
	   for(int i=0;i<20;i++){	
		   woTou=new WoTou(i);
		   stack.push(woTou);
		   System.out.println("生产了："+woTou);
		   try {
			Thread.sleep((int)Math.random()*1000);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
	   }
	}
	
}
//消费者类
class Comsumer implements Runnable{
	
  private SyncStack stack=null;
  public Comsumer(SyncStack stack){
  	this.stack=stack;
  }
	public void run() {
		WoTou woTou=null;
	   for(int i=0;i<20;i++){	
		   woTou=stack.pop();
		   System.out.println("消费了："+woTou);
		   try {
				Thread.sleep((int)Math.random()*1000);
			} catch (InterruptedException e){
				e.printStackTrace();
			}
	   }
	}
	
}

5.1 线程同步
      5.1.1 当用synchronized来修饰一个方法或代码块的时候，能够保证在同一时刻最多只能只有
     一个线程执行该段代码
      5.1.2 当两个并发线程访问同一对象object中的这个synchronized(this)同步代码块时，一个时间内
      只能有一个线程得到执行。另外一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块
      5.1.3 当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该
      object的非synchronized(this)同步代码块
      5.1.4 *当一个线程访问object的一个synchronize(this)代码块，其他线程对该object中所有其他
      synchronized(this)同步代码块的访问将被阻塞
      5.1.5 synchronized同步方法、synchronized同步方法块
      5.1.6 死锁就是指多个进程(线程)因竞争资源(系统资源竞争、程序推进顺序非法)而造成的一种僵局

      5.1.7 死锁产生的必要条件：互斥条件、不可剥夺条件、请求和保持条件、循环等待链条件

             

               线程同步demo:

public class TestSync implements Runnable {
 
	Timer timer=new Timer();
	
	public static void main(String[] args) {
       TestSync test=new TestSync();
       Thread thread1=new Thread(test);
       Thread thread2=new Thread(test);
       thread1.setName("t1");
       thread2.setName("t2");
       thread1.start();
       thread2.start();
	}

	public void run() {
       timer.add(Thread.currentThread().getName());
	}
}

class Timer {
	private static int num = 0;
	public void add(String name) {
		synchronized (this) {
			num++;
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				
			}
			System.out.println(name + ",你是第" + num + "个使用timer的线程");
		}
	}
}
               线程死锁： 

public class DeadLock {
	public static void main(String[] args) {
		Object o1 = new Object();
		Object o2 = new Object();
		
		Thread t1 = new T1(o1,o2);
		Thread t2 = new T2(o1,o2);
		
		t1.start();
		t2.start();
	}
}

class T1 extends Thread{
	
	Object o1;
	Object o2;
	
	T1(Object o1,Object o2){
		this.o1 = o1;
		this.o2 = o2;
	}
	
	public void run() {
		synchronized (o1) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (o2) {
				
			}
		}
	}
}

class T2 extends Thread{
	
	Object o1;
	Object o2;
	
	T2(Object o1,Object o2){
		this.o1 = o1;
		this.o2 = o2;
		
	}
	
	public void run() {
		synchronized (o2) {
			synchronized (o1) {
				
			}
		}
	}
}
               经典多线程面试题 
public class TT implements Runnable{

	private int b=100;
	
	public synchronized void m1() throws Exception{
		b=1000;
		Thread.sleep(5000);
		System.out.println("b = "+b);
	}
//       1.
	public void m2() throws Exception{
		Thread.sleep(2500);
		b=2000;
	}
	
//       2.
//		public synchronized void m2() throws Exception{
//			Thread.sleep(2500);
//			b=2000;
//		}
	public void run() {
		try {
			m1();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
    public static void main(String[] args) throws Exception{
		TT tt=new TT();
		Thread t=new Thread(tt);
		t.start();
		tt.m2();
		System.out.println(tt.b);
    }
	
}


先绅
关注
专栏目录
Python解析HttpRuner框架实现解析yml文件，构造接口请求通过执行多线程参数化完成接口测试
Benjamin CSDN博客
03-05 1068
前言： HttpRunner是一大神器配合Charles或者Fiddler抓包导出Har文件，可实现最简单的接口录制和回放。Har包也很容易被转化为yml供HttpRunner框架使用。 本次练习和使用的场景主要是解决HttpRunner框架不熟悉或者操作不便，实现接口测试更多的玩法更能配合实现多线程接口测试。这里只介绍简答的入门示例提供思路，深入的自己玩去吧。 业务场景分析： 基于HttpRunner的性能测试或者单个yml文件连续请求多次的使用方法不是很熟悉...
python-多线程
qq_33537936的博客
01-06 408
多线程线程和进程的关系基本的多线程多线程共享全局变量线程锁自定义线程类线程池第三方线程池(threadpool)GIL锁（全局解释器锁）多线程使用场景 线程和进程的关系 一个线程只能属于一个进程，而一个进程可以有多个线程。 进程拥有资源，线程不拥有资源，线程共享进程的资源。 处理机分给线程，即真正在处理机上运行的是线程。 线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的可调度实体。 同属于一个进程中的线程可以共享C
httpclient 多线程执行（原创）
01-23 1406
httpclient 多线程执行（原创）
httprunner框架使用小记-1
城先生的博客
06-20 220
WM工作2年使用的httpruner框架的心得小记
「httprunner」安装执行命令
小星星的博客
07-15 558
一、安装环境准备： pip install httprunner==2.5.7 pip install har2case 检查是否安装成功： httprunner -V hrun -V 二、执行命令： har2case my_demo.har —>将har文件转json格式 har2case my_demo.har -2y —>将har文件转yml格式 hrun my_demo.yml —>运行测试用例 运行完成如下图： ...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Linux 多线程原理深剖
热门推荐
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
Python-httprunner接口契约校验
08-10
公司前端吐槽后台接口有时会更改返回的数据结构，返回的字段名与字段类型与接口文档不一致，希望有一个快速检测接口返回数据的所有字段名与字段类型的方法
POSIX多线程程序设计.pdf
12-02
《POSIX多线程程序设计》深入描述了IEEE的开放系统接口标准——POSIX线程，通常称为Pthreads标准。本书首先解释了线程的基本概念，包括异步编程、线程的生命周期和同步机制；然后讨论了一些高级话题，包括属性对象、...
Qt界面多线程opencv调用摄像头
05-09
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论...
【进阶】 --- 多线程、多进程、异步IO 实用例子
freeking101的博客
11-13 1777
在编写爬虫时，性能的消耗主要在IO请求中，当单进程单线程模式下请求URL时必然会引起等待，从而使得请求整体变慢。以下代码默认运行环境为 python3。 目录 一、多线程、多进程 1.同步执行 2.多线程执行 3.多线程+回调函数执行 4.多进程执行 5.多进程+回调函数执行 二、异步 1.asyncio示例1 asyncio示例2 2.asyncio + aiohttp 3.asyncio + request...
接口自动化框架httprunner(四)--用例执行
luoman876的博客
05-16 819
HttpRunner 在命令行中启动测试时，通过指定参数，可实现丰富的测试特性控制。 使用命令是:hrun hrun -h 可以列出所有支持的参数； 运行测试用例： 1、运行单个或者多个指定的测试用例； $ hrun filepath/testcase1.yml [filepath/testcase2.yml…] 2、运行文件夹中的所有用例： $ hrun testcases_folder_path ...
Aandroid 多线程断点续传同时下载多个大文件
05-21
在Android开发中，多线程、断点续传和同时下载多个大文件是优化用户体验和提高应用程序性能的关键技术。下面将详细阐述这些知识点，并提供如何实现的指导。 **多线程** 多线程是Android应用中处理耗时操作的重要...
从C++软件调试实战的角度去看多线程编程中的若干细节问题
最新发布
dvlinker的技术专栏
11-12 1万+
本文从C++软件调试实战的角度去讲述多线程编程中的若干细节问题，并给出了具体的问题分析实例。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值