线程

最新推荐文章于 2024-08-23 23:28:12 发布
最新推荐文章于 2024-08-23 23:28:12 发布
阅读量111 收藏
点赞数
分类专栏： java语言初级 文章标签： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39205579/article/details/99705107
版权

线程 Thread

一、定义

进程中的一个执行控制单元，执行路径

线程分类：

  • 单线程：安全性高，但是效率低
  • 多线程：安全性低，但是效率高

  • 二、创建线程的几种方式

    1. 继承Thread类,重写run()方法
      • run()定义线程体
      • start() 开启线程
    3. 实现Runnable接口,重写run()方法 ---推荐
    4. 实现Callable接口,重写call()方法:了解

    2.1、继承Thread类

    步骤实例：

    //继承Thread类
public class ThreadDemo01 extends Thread{
	//定义线程体
	@Override
	public void run() {
		for(int i=1;i<=100;i++){
			System.out.println("一边吃饭.....");
		}
	}
	
	public static void main(String[] args) {
		//创建线程对象:创建Thread子类的对象
		ThreadDemo01 th=new ThreadDemo01();
		//开启线程 :准备好了,cpu可以调度了
		th.start();  
        //th.run(); //方法的调用,单线程,run()执行完毕以后才会继续执行main方法中的代码
        //默认主线程
		for(int i=1;i<=100;i++){
			System.out.println("一边说话.....");
		}
	}
}
    2.2、实现Runnable接口类

    步骤实例：

    //实现Runnable接口
public class ThreadDemo02 implements Runnable{
	//重写run方法
	@Override
	public void run() {
		for(int i=1;i<=20;i++){
            //捕捉异常
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("一边学习.....");
		}
	}
	
	public static void main(String[] args) {
		//利用静态代理
		ThreadDemo02 th=new ThreadDemo02();
		Thread t=new Thread(th);
        //开启线程
		t.start();
		
		for(int i=1;i<=20;i++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("一边陪女朋友.....");
		}
	}

}

    优点：

  • 避免单继承的局限性
  • 实现资源共享

  • 2.3、匿名内部类实现方式
    public class Test01 {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for(int i=0;i<10;i++){
					System.out.println(Thread.currentThread().getName()+"我是匿名内部类");
				}
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}).start();
	}
}
    2.4、Lambda实现方式
    new Thread(()->{
				for(int i=0;i<20;i++){
					try {
						Thread.sleep(2);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("一遍嘿嘿笑...");
				}
			}).start();
    2.5、内部类实现方式
    public class Demo02 {
	static class Inner implements Runnable{
		//静态内部类
		@Override
		public void run() {
			for(int i=0;i<20;i++){
				try {
					Thread.sleep(2);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("一遍讲课...");
			}
		}
		
	}
	public static void main(String[] args) {
		new Thread(new Inner()).start();
	}
}
    2.6、火车购票实例
    public class Web12306_03 implements Runnable{
	int tickets=100;  //100张票

	/*
	 * 买票的流程功能
	 */
	@Override
	public void run() {
		while(true){
			//结束买票的条件
			if(tickets<=0){
				break;
			}
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//static Thread currentThread();返回当前线程对象
			System.out.println(Thread.currentThread().getName()+"正在买第"+tickets--);
		}
	}
	
	public static void main(String[] args) {
		Web12306_03 web=new Web12306_03();  //100
		//创建线程  资源共享
		Thread th1=new Thread(web,"张三");
		Thread th2=new Thread(web,"李四");
		Thread th3=new Thread(web,"王五");
        //开启线程
		th1.start();
		th2.start();
		th3.start();
	}
	
}

    注：当多个线程同时操作同一份资源的时候,可能会出现线程不安全问题

    三、线程的状态

    有5种状态：

    • 新生: new Thread()
    • 就绪: start(),就绪状态的线程会进入到就绪队列中,等待cpu调度
    • 运行: 当cpu非配时间片给线程,这个线程就会进入运行状态开始运行
    • 阻塞: sleep()...
    • 终止: 线程结束

    注：

    1. 如果一个线程进入阻塞状态,阻塞状态解除也无法直接进入运行状态,会进入就绪状态
    2. 如果一个线程已经死亡,无法恢复就算重新开启线程也不是原来的那一个

    3.1

    1）如何进入终止状态
    • 正常执行完毕
    • 添加外部表示判断
    2）如何进入就绪状态
    • start()
    • 阻塞状态解除
    • yield()
    • 线程切换
    3）如何进入阻塞状态
    • sleep()
    • wait()
    • join()
    • IO 操作

    sleep(ms) 线程睡眠.. （抱着资源睡觉）

  • 模拟网络延迟
  • 放大发生问题的可能性

  • 3.2、yield()方法

    会让出cpu的资源,让线程直接进入就绪状态

    public class YieldDemo02 {
	
	static class Inner implements Runnable{

		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName()+"开始执行");
			Thread.yield();
			System.out.println(Thread.currentThread().getName()+"结束执行");
		}
		
	}
	
	public static void main(String[] args) {
		Inner in=new Inner();
		new Thread(in,"A" ).start();
		new Thread(in,"B" ).start();
	}
	
	
}

    3.3、join()方法

    也叫插队方法，使被插队的线程进入阻塞状态

    3.4、获取线程状态的方法

    getState() 返回线程的枚举类型状态值

    线程的优先级:  1~10  1最小  10最大   默认5

  • int getPriority()  返回线程的优先级
  • void setPriority(int newPriority)  更改线程的优先级

  • public class StateDemo04 {
	public static void main(String[] args) {
		Thread th=new Thread(()->{
			for(int i=1;i<=10;i++){
				if(i==5){
					try {
						Thread.sleep(2000);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		});
		System.out.println(th.getState());  
		th.start();
		System.out.println(th.getPriority());
		Thread th2=new Thread(()->{System.out.println("哈哈哈2");});
		Thread th3=new Thread(()->{System.out.println("哈哈哈3");});
		System.out.println(th2.getPriority());
		System.out.println(th3.getPriority());
		th2.setPriority(1);
		th3.setPriority(6);
		th2.start();
		th3.start();
	}
}

    四、线程安全

    当多线程，同时操作同一份资源的时候有可能存在线程不安全问题

    如何控制线程安全：

  • 锁-->同步锁 synchronized

  • 1)、同步方法

    使用关键字synchronized修饰的方法，一旦被一个线程访问，则整个方法全部被锁住，其他线程则无法访问。

    public void run() {
		while(true){
			payTicket();
		}
		
	}

public  synchronized void payTicket() {
	if(tickets>0){	
         try{
             Thread.sleep(200);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         System.out.println(Thread.currentThread().getName()+"正在买"+tickets--);
	}
}

  • 静态方法

  • public static synchronized void payTicket() {
	if(tickets>0){	
         try{
             Thread.sleep(200);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         System.out.println(Thread.currentThread().getName()+"正在				买"+tickets--);
	}
}
    2）、同步块

    格式： synchronized(引用类型|对象|类)

    public void run() {
		while(true){
			//结束买票的条件
            //锁类
			synchronized (Web12306_02.class) {
				if(tickets<=0){
					break;
				}
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在买第"+tickets--);
			}
		}
	}

    注：

  • 锁要锁不变的内容,才能锁住
  • 锁的范围太大,效率低,锁的范围太小,锁不住

汀幽
关注
专栏目录
【多线程】线程池
王佑辉的博客
04-04 5968
3.keepAliveTime：多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。7.handler：拒绝策略，表示当队列满了并且工作线程-大于等于线程池的数量最大线程数（maxinumPoolSize）时如何来拒绝请求执行的runnable的策略。6.threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。
Qt 线程
qq_45303986的博客
02-20 6819
QThread(线程)，代表一个在应用程序中可以独立控制的线程，可以和进程中的其他线程分享数据。QThread 对象管理程序中的一个控制线程。QThreads 在 run（） 中开始执行。默认情况下，run（） 通过调用 exec（） 来启动事件循环，并在线程内运行 Qt 事件循环。
【JavaEE】线程安全性问题，线程不安全是怎么产生的，该如何应对
最新发布
yican2580的博客
08-23 1万+
本章分析了在Java多线程编程中产生线程不安全的原因，将每一个原因举例子并分析解决方法。了解死锁产生的原因，分析如何避免死锁的发生。
【Java】了解线程 Thread 类的使用，如何创建、终止、等待一个线程以及获取线程的状态
yican2580的博客
08-21 3561
了解线程 Thread 类的使用，如何创建、终止、等待一个线程。
Java线程
m0_56188609的博客
02-22 3005
两个线程同时运行均要使用CPU，While(ture)为死循环，两个线程均需要不断使用CPU，而两个线程大量使用CPU会造成CPU占用率达到100%，其他代码、操作系统其他程序就会暂停卡住。因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码（从使用CPU到不适用CPU称之为线程的一次上下文切换）当然它的底层是否由多个核心对这两个线程并行执行还是一个核心对它们并发处理，包括打印的前后顺序是不由我们控制的。（快照：只能查看某一刻） 查看某个 Java 进程（PID）的所有线程状态。
多线程 join 方法
Gonelin的博客
12-22 6341
多线程 join 方法 1.前言 本节对 join 方法进行深入的剖析，主要内容点如下： 了解 join 方法的作用，初步的理解 join 方法的使用带来的效果是学习本节内容的基础； 了解 join 方法异常处理，我们在使用 join 方法是，需要对 join 方法进行有效的异常处理； 通过匿名内部类创建Thread 是我们本节代码示例所使用的的方式，对这种方式的掌握在后续工作中非常重要； 掌握 join 方法如何使用，这是本节的重点内容，也是本节的核心内容； 掌握带参数的 join 方法使用，在后续开发
解析Python中获取当前线程名字的方法及多线程编程实践
一键难忘的博客
04-27 2759
在多线程编程中，了解当前线程的名字是一项重要的任务。Python 提供了内置的线程模块 `threading`，通过它我们可以轻松地获取当前线程的名字。本文将介绍如何在 Python 中获取当前线程的名字，并探讨一些相关的背景知识。
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
线程实质
修行之路
03-16 3328
线  程 线程与进程的比较 概述: 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享
进程与线程
热门推荐
程序媛泡泡的博客
03-18 8万+
进程与线程 1 进程 1.1 进程的概念 进程就是正在运行的程序,它代表了程序所占用的内存区域 1.2 进程的特点 独立性 进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间 动态性 进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的. 并发性 多个进程可以在
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
POSIX多线程程序设计.pdf
12-02
《POSIX多线程程序设计》深入描述了IEEE的开放系统接口标准——POSIX线程，通常称为Pthreads标准。本书首先解释了线程的基本概念，包括异步编程、线程的生命周期和同步机制；然后讨论了一些高级话题，包括属性对象、...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
通过Stack Overflow线程栈溢出的问题实例，详解C++程序线程栈溢出的诸多细节
dvlinker的技术专栏
08-04 1万+
通过Stack Overflow线程栈溢出的问题实例，详解C++程序线程栈溢出的诸多细节
从C++软件调试实战的角度去看多线程编程中的若干细节问题
dvlinker的技术专栏
11-12 1万+
本文从C++软件调试实战的角度去讲述多线程编程中的若干细节问题，并给出了具体的问题分析实例。
Java线程优先级详解
"Java线程的优先级管理是多线程编程中的一个重要概念，它涉及到线程调度和执行的顺序。在Java中，线程的优先级被用来影响线程被操作系统选择执行的概率，但并不保证高优先级的线程一定会先于低优先级的线程执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值