【无标题】

于 2021-11-22 17:26:19 发布
阅读量127 收藏
点赞数
分类专栏： java项目学习分类 文章标签： 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53123681/article/details/121442268
版权
本文详细讲解了线程的基本概念、创建与启动、优先级调整、守护线程、生命周期管理，以及线程安全与同步方法，包括synchronized关键字、Lock接口的应用。通过实例演示了如何避免数据一致性问题，确保线程间的协作有效。
摘要由CSDN通过智能技术生成

多线程

电脑中时会有很多单独运行的程序，每个程序有一个独立的进程，而进程之间是相互独立存在的。进程想要执行任务就需要依赖线程。换句话说，就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。
　1.线程中常用的方法
　　1.static Thread currentThread()得到当前正在运行的线程对象
　　2.void start() 启动线程
　　3.String getName()返回该线程的名称。
　　　1.当没有设置线程名称的时候，系统会赋予线程一个默认的名称“Thread-0,Thread-1…”
　　　2.主线程【主方法的执行线程】的名称默认是“main”
　　4.void setName(String name)设置线程名称
例如:

package com.wangxing.zyb1;
public class MyThread1 implements Runnable{
	@Override
	public void run() {
		for(int i=1;i<=20;i++) {
			//static Thread currentThread()得到当前正在运行的线程对象
			Thread  th=new Thread();
			String name=th.getName();
			System.out.println(name+",i=="+i);
		}
	}
}

package com.wangxing.zyb1;
public class Main {
	public static void main(String[] args) {
	//主方法执行线程的名称
	String name=Thread.currentThread().getName();
	System.out.println("主方法执行的名称="+name);
	//创建目标对象
	MyThread1 my=new MyThread1();
	//创建线程对象
	Thread th1 = new Thread(my);
	Thread th2 = new Thread(my);
	th1.setName(name);
	th2.setName(name);
	//void start() 启动线程
	th1.start();
	th2.start();
	}
}

在这里插入图片描述
线程的优先级—就是线程的执行先后，默认情况下所有线程的优先级都是一样，都是5。
我们可以通过void setPriority(int newPriority) 更改线程的优先级。
　1.线程的优先级有10个级别，分别使用整数1~10来表示。数字越大优先级越高。
　2.为了方便操作，java将10个级别有规定成3个级别，分别是最低的优先级，中等优先级，最高的优先级，并且将这3个级别封装成了静态常量 static int MAX_PRIORITY 线程可以具有的最高优先级。
　　static int MIN_PRIORITY线程可以具有的最低优先级。1
　　static int NORM_PRIORITY分配给线程的默认优先级。5
　　int getPriority() 返回线程的优先级。
　3.设置线程的优先级的时候，数字越大优先级越高，数字越小优先级越低。优先级越高并代表就一定会优先执行，只是被优先执行的几率增大，因此不要试图通过控制线程的优先级，来保证某一个线程，总是第一个执行。
例如:

package com.wangxing.zyb2;

public class MyThread1 implements Runnable{

	@Override
	public void run() {
		for(int i=1;i<=20;i++) {
			//static Thread currentThread()得到当前正在运行的线程对象
			Thread  th=new Thread();
			String name=th.getName();
			System.out.println(name+",i=="+i);
		}
	}
}

package com.wangxing.zyb2;
public class Main {
	public static void main(String[] args) {
	//主方法执行线程的名称
	String name=Thread.currentThread().getName();
	//主方法执行线程的优先级
	//int getPriority() 返回线程的优先级。
	int mainpri=Thread.currentThread().getPriority();
	System.out.println("主方法执行线程的名称=="+name+"，优先级=="+mainpri);
	//创建目标对象
	MyThread1 my=new MyThread1();
	//创建线程对象
	Thread th1 = new Thread(my);
	Thread th2 = new Thread(my);
	//void setName(String name)设置线程名称
	th1.setName("线程1");
	th2.setName("线程2");
	//void	setPriority(int newPriority) 更改线程的优先级。
	//线程的优先级有10个级别，分别使用整数1~10来表示。数字越大优先级越高。
	//为了方便操作，java将10个级别有规定成3个级别用静态常量表示
	th1.setPriority(10);
	th2.setPriority(Thread.MIN_PRIORITY);
	//int	getPriority() 返回线程的优先级。
	int th1pri=th1.getPriority();
	int th2pri=th2.getPriority();
	System.out.println("线程1的优先级=="+th1pri);
	System.out.println("线程2的优先级=="+th2pri);
	//void start() 启动线程
	th1.start();
	th2.start();
	}
}

守护线程的相关操作方法
　用户线程----通常情况之下我们所创建的线程都是普通线程，非守护线程，也叫用户线程。
　守护线程----也叫精灵线程,当所有用户线程都执行完毕以后，自动结束运行的线程就是守护线程.[共死]
　1.boolean isDaemon() 测试该线程是否为守护线程。
　2.void setDaemon(boolean on) 将该线程标记为守护线程用户线程。
　特征：当所有用户线程都执行完毕以后，无论守护线程能否可以继续运行，都要立刻停止运行。
例如:

package com.wangxing.zyb3;
public class MyThread1 implements Runnable{
	@Override
	public void run() {
		for(int i=1;i<=20;i++) {
			//static Thread currentThread()得到当前正在运行的线程对象
			Thread  th=new Thread();
			String name=th.getName();
			System.out.println(name+",i=="+i);
		}
	}
}

package com.wangxing.zyb3;
public class MyThread2 implements Runnable{
	@Override
	public void run() {
		while(true) {
			Thread  th=Thread.currentThread();
			String name=th.getName();
			System.out.println(name);
		}
	}
}

package com.wangxing.zyb3;
public class Main {
	public static void main(String[] args) {
	//创建目标对象
	MyThread1 my1=new MyThread1();
	MyThread1 my2=new MyThread1();
	//创建线程对象
	Thread th1 = new Thread(my1,"用户线程");
	Thread th11 = new Thread(my1,"用户线程");
	Thread th2 = new Thread(my2,"用户线程");
	//void	setDaemon(boolean on) 将该线程标记为守护线程用户线程。
	th2.setDaemon(true);
	//void setName(String name)设置线程名称
	th1.setName("线程1");
	th2.setName("线程2");
	//boolean	isDaemon() 测试该线程是否为守护线程。
	System.out.println("th1==="+th1.isDaemon());
	System.out.println("th2==="+th2.isDaemon());
	//启动线程
	th1.start();
	th11.start();
	th2.start();
	}
}

static void sleep(long millis) 设置线程休眠【暂停】指定的时间【毫秒】
例如:闹钟程序

package com.wangxing.zyb4;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.Date;
public class NaoZhong{
	public static void main(String[] args)throws Exception {
		System.out.println("设置一个闹钟");
		BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
		String nzsj=input.readLine();
		SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");
		boolean flag=true;
		while(flag) {
			String dqsj=sdf.format(new Date());
			if(dqsj.equals(nzsj)) {
				flag=false;
			}
			System.out.println(dqsj);
			Thread.sleep(1000);
		}
		System.out.println("闹钟响起");
	}
}

在这里插入图片描述
void interrupt() 中断线程休眠【暂停】。会进入异常【InterruptedException】。
例如:

package com.wangxing.zyb4;
public class MyThread1 implements Runnable{
	@Override
	public void run() {
		//得到当前线程的名称
		String name=Thread.currentThread().getName();
		System.out.println(name+"开始听讲");
		//设置static void	sleep(long millis) 设置线程休眠【暂停】指定的时间【毫秒】
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(name+"打瞌睡...");
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			System.out.println(name+"被老师叫醒");
			System.out.println(name+"继续开始听课");
			try {
				Thread.sleep(5000);
			}catch(InterruptedException e1) {
				e1.printStackTrace();
			}
			System.out.println("下课了");
		}
	}
}

package com.wangxing.zyb4;
public class Main {
	public static void main(String[] args) {
		System.out.println("铃铃铃！上课了");
		MyThread1 my=new MyThread1();
		Thread th=new Thread(my);
		th.getName();
		th.start();
		System.out.println("老师开始上课");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			
			e.printStackTrace();
		}
		System.out.println("老师发现童鞋睡着了");
		System.out.println("老师过去叫醒了同学");
		th.interrupt();
	}
}

void join(long millis)【强制线程执行】等待该线程终止的时间最长为 millis 毫秒。

例如：

package com.wangxing.zyb5;
public class MyThread1 implements Runnable{
	@Override
	public void run() {
		for(int i=1;i<=20;i++) {
			//得到当前线程的名称
			String name=Thread.currentThread().getName();
			System.out.println(name+",i=="+i);
		}
	}
}

package com.wangxing.zyb5;
public class Main {
	public static void main(String[] args) {
		// 创建目标对象
		MyThread1 my = new MyThread1();
		// 创建线程对象
		Thread th1 = new Thread(my);
		// 设置名字
		th1.setName("线程1");
		th1.start();
		for (int i = 1; i <= 20; i++) {
			// 得到当前线程的名称
			String name = Thread.currentThread().getName();
			System.out.println(name + ",i==" + i);
			if (i == 10) {
				// 强制线程1执行
				// void join(【long millis】)【强制线程执行】等待该线程终止的时间最长为 millis 毫秒。
				try {
					th1.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

2.线程的生命周期
1、线程的生命周期就是线程从一开始创建，到run方法执行完毕以后的状态变化。[状态之间的切换]
2、线程的生命周期几种状态【1、新建状态 2、就绪状态 3、运行状态 4.阻塞状态 5.死亡状态】
参考图片1.png
在这里插入图片描述
线程的生命周期描述
　1.新建状态:通过new的方式创建出线程对象，此时线程就进入到创建状态【新建状态】。
　　新建状态的线程是不能运行。
　　新建状态的线程调用start方法，进入就绪状态
2.就绪状态:线程具备运行能力，只差操作系统【CPU】分配给他运行时间片
　　得到操作系统【CPU】分配给他运行时间片，此时开始执行run方法，进入运行状态。
　3.运行状态：线程运行run方法。
　　回到就绪状态：
　1.操作系统【CPU】分配给他运行时间片使用完毕，回到就绪状态。
　　进入阻塞状态
　　1.运行状态的线程执行了sleep方法，进入阻塞状态。
　　2.运行状态的线程执行了wait方法，进入阻塞状态。
　　3.运行状态的线程执行输入/输出动作，进入阻塞状态。
　　…
　　进入死亡状态
　　1.运行状态的线程run方法执行完毕，进入死亡状态。
　　2.运行状态的线程调用stop()/destroy() ，进入死亡状态。
　4.阻塞状态:线程暂停运行
　　回到运行状态
　　阻塞状态中的线程，结束了造成阻塞的原因，此时线程进入就绪状态，得到操作系统【CPU】分配给他运行时间片就可以进入运行状态。
　　运行状态进入阻塞状态原因：
　　1.运行状态的线程执行了sleep方法，进入阻塞状态，休眠时间结束/interrupt，进入就绪状态
　　2.运行状态的线程执行了wait方法，进入阻塞状态，调用notify/notifyAll,进入就绪状态
　　3.运行状态的线程执行输入/输出动作，进入阻塞状态，输入/输出结束，进入就绪状态
　5.死亡状态:线程运行结束，释放运行资源。
　　死亡状态的线程是不能运行，除非再一次使用strat方法重新启动运行。
　3.线程安全
　　卖票实例:

package com.wangxing.zyb6;
public class MyThread1 implements Runnable{
	private int piao=20;
	@Override
	public void run() {
		//得到当前线程的名称
		String name=Thread.currentThread().getName();
		//持续买票
		boolean flag=true;
		while(flag) {
			//判断有没有可卖的票
			if(piao>0) {
				//收钱--找钱--打印票
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(name+",卖出1张票，还剩"+(--piao)+"张");
			}else {
				flag=false;
			}
		}
	}
}

package com.wangxing.zyb6;

public class Main {
	public static void main(String[] args) {
		// 创建目标对象
		MyThread1 my = new MyThread1();
		// 创建线程对象
		Thread th1 = new Thread(my);
		Thread th2 = new Thread(my);
		Thread th3 = new Thread(my);
		// 设置名字
		th1.setName("线程1");
		th2.setName("线程2");
		th3.setName("线程3");
		th2.setPriority(10);
		th1.start();
		th2.start();
		th3.start();
	}
}

运行结果:
在这里插入图片描述
　　分析结果:当窗口1卖最后一张票的时候，在收钱打印票的时候，还没有来得及对票数进行减1之前，线程就切换给了窗口3,窗口3认为还有一张票，窗口3就收钱收钱打印票的时候，还没有来得及对票数进行减1之前，线程有切换给了窗口1，窗口1就对票数进减1，完成以后线程切换给窗口3，窗口3对对票数进行减1此时就得到-1这个值。
　　经过上面运行程序的分析，我得到的结果是:当多条线程，同时访问同一个资源的时候，会产生数据不一致的错误情况。为了解决这种数据不一致的错误情况，我们才学习线程同步。
　什么是线程同步/线程安全？
　　线程同步也叫线程安全，当多条线程，同时访问同一个资源的时候,每一次只能由多条线程中的其中一条访问公共资源，当这一条线程访问公共资源的时候，其他的线程都处于等待状态，不能访问公共资源，当这一条线程访问完了公共资源以后，其他线程中的一条线程才能访问资源，剩下的线程继续等待，等待当前线程访问结束，实现这个过程就是线程同步。【排队访问资源】
　线程同步/线程安全的实现方式有几种，分别是什么，有什么区别？
　　1.Synchronized关键字 【同步代码块/同步方法】
　　1.同步代码块
　格式:synchronized(同步对象){
　
　　 }
例如:

package com.wangxing.zyb6;
public class MyThread2 implements Runnable {
	private int piao = 20;
	@Override
	public void run() {
		// 得到当前线程的名称
		String name = Thread.currentThread().getName();
		// 持续买票
		boolean flag = true;
		while (flag) {
			// 同步代码块
			synchronized (this) {
				// 判断有没有可卖的票
				if (piao > 0) {
					// 收钱--找钱--打印票
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(name + ",卖出1张票，还剩" + (--piao) + "张");
				} else {
					flag = false;
				}
			}
		}
	}
}

package com.wangxing.zyb6;
public class Main {
	public static void main(String[] args) {
		// 创建目标对象
		MyThread2 my = new MyThread2();
		// 创建线程对象
		Thread th1 = new Thread(my);
		Thread th2 = new Thread(my);
		Thread th3 = new Thread(my);
		// 设置名字
		th1.setName("线程1");
		th2.setName("线程2");
		th3.setName("线程3");
		th2.setPriority(10);
		th1.start();
		th2.start();
		th3.start();
	}
}

同步代码块虽然可以实现买票的效果，但是它在使用的时候，需要设置一个同步对象，由于我们很多时候都不知道这个同步对象应该是谁，容易写错，造成死锁的情况。正是应为这个缺点，我们很少使用同步代码块来实现线程同步。
　2.同步方法
　　同步方法的定义格式: 访问限制修饰符 synchronized 方法返回值类型 方法名称(){

		            }

例如:

package com.wangxing.zyb6;
public class MyThread3 implements Runnable {
	private int piao = 20;
	//持续买票
	boolean flag = true;
	@Override
	public void run() {
		// 得到当前线程的名称
		String name = Thread.currentThread().getName();
		while (flag) {
			sellpiao(name);
		}
	}
	private synchronized void sellpiao(String name) {
		//判断有没有可卖的票
		if(piao>0) {
			//收钱--找钱--打印票
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(name+",卖出1张票，还剩"+(--piao)+"张");
		}else {
			flag=false;
		}
	}
}

package com.wangxing.zyb6;
public class Main {
	public static void main(String[] args) {
		// 创建目标对象
	　MyThread3 my = new MyThread3();
		// 创建线程对象
		Thread th1 = new Thread(my);
		Thread th2 = new Thread(my);
		Thread th3 = new Thread(my);
		// 设置名字
		th1.setName("线程1");
		th2.setName("线程2");
		th3.setName("线程3");
		th2.setPriority(10);
		th1.start();
		th2.start();
		th3.start();
	}
}

2.通过Lock接口
　public interface Lock
　常用的接口方法
　void lock() 获得锁。
　void unlock() 释放锁。
　　由于上面的锁方法是Lock接口，我们要使用就得先创建出Lock接口对象，由于Lock是个接口不能new ,我们就得使用它的子类来创建对象。Lock接口得子类ReentrantLock
例如:

package com.wangxing.zyb6;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyThread4 implements Runnable {
	private int piao = 20;
	//定义Lock对象
	private Lock Mylock=new ReentrantLock();
	@Override
	public void run() {
		// 得到当前线程的名称
		String name = Thread.currentThread().getName();
		持续买票
		boolean flag=true;
		while (flag) {
			//void lock() 获得锁。 
			Mylock.lock();
			//判断有没有可卖的票
			if(piao>0) {
				//收钱--找钱--打印票
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(name+",卖出1张票，还剩"+(--piao)+"张");
			}else {
				flag=false;
			}
			//void	unlock() 释放锁。
			Mylock.unlock();
		}
	}
}

package com.wangxing.zyb6;
public class Main {
	public static void main(String[] args) {
		// 创建目标对象
		MyThread4 my = new MyThread4();
		// 创建线程对象
		Thread th1 = new Thread(my);
		Thread th2 = new Thread(my);
		Thread th3 = new Thread(my);
		// 设置名字
		th1.setName("线程1");
		th2.setName("线程2");
		th3.setName("线程3");
		th2.setPriority(10);
		th1.start();
		th2.start();
		th3.start();
	}
}

Synchronized关键字与Lock接口的区别？
synchronized：
　　1.synchronized关键字
　　2.自动锁定资源,不灵活
　　3.异常时会自动释放锁
　　4.不能中断锁，必须等待线程执行完成释放锁。
　Lock:
　　1.Lock接口
　　2.手动锁定资源，灵活
　　3.异常时不会自动释放锁，所以需要在finally中实现释放锁
　　4.可以中断锁

weixin_53123681
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的多线程2
weixin_52821030的博客
11-22 375
1.线程中常用的方法 1.static Thread currentThread()得到当前正在运行的线程对象 2.void start()启动线程 3.String getName()返回该线程的名称 1.当没有设置线程名称的时候，系统会赋予线程一个默认的名称"Thread-0,Thread-1".... 2.主线程【主方法的执行线程】的名称...
黑马程序员---java学习笔记之多线程2
yizhanhaha的专栏
12-20 515
1、Object类中的wait方法，notify方法，notifyAll方法只能用在同步中(同步函数或者同步代码块)。 2、视频中老师线程通信的生产者与消费者之间的例子(我做了一些修改) public class ProducerConsumerDemo { public static void main(String[] args) { // TODO Auto-generated
实现多线程的几种方法-Java
qq_42411214的博客
03-04 301
文章目录实现 Runnable接口方式实现多线程继承Thead方法实现多线程匿名内部类通过Callable和FutureTask创建线程通过线程池创建线程 实现 Runnable接口方式实现多线程 自定义类实现Runnable接口，将自定义类的对象传入Thread构造函数的参数。 Thread构造函数 Thread(Runnable target, String name) 分配一个新的 Thre...
java之学习多线程（二）
唐人的博客
08-28 511
java中Thread和Runnabel实现多线程是有所区别的，使用Runnable接口可以有效解决java中单继承带来的局限性。并且Thread类也是Runnable接口的子类： public class Thread extends Object implements Runnable     下面来通过一个利用多线程实现的买票小程序来了解一下Thread和Runnable实现多线城市在对内
Java并发多线程编程——获取默认线程名称及自定义线程名称
小志的博客
04-08 780
目录一、获取线程默认名称案例二、如何自定义线程名称二、自定义线程名称案例 一、获取线程默认名称案例 1、代码 package com.xz.thread.t1; /** * @description: * @author: xz */ public class Demo1 extends Thread{ @Override public void run() { System.out.println(getName()+"正在运行。。。。。。。。。"); }
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
Delphi实现拖动按钮移动无标题栏窗口
05-11
摘要:Delphi源码,界面编程,窗体拖动,无标题栏 无标题栏的窗体的拖动功能实现，Delphi添加一个可拖动窗体的按钮，通过对此按钮的控制可移动窗体，实现按住标题栏移动窗口的功能，无标题栏也就不能显示最大化、最小化...
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
visual c++取掉对话框窗口的 -无标题 字样的方法
08-04
在Visual C++编程环境中，创建窗口应用程序时，默认情况下，窗口标题栏可能会显示“-无标题”字样，这通常是由于没有正确设置窗口类或没有自定义窗口标题所导致的。要解决这个问题，我们需要深入理解Windows API中的...
Executor 线程池
风归去.
10-18 201
前几天在工作中，遇到了线程池的问题，突然发现有很多不会的东西，然后就查资料，文档进行学习。 总结一下内容，方便自己以后进行查阅复习。 Executor 线程池_学习笔记 1.线程 1.1 线程 线程是调度 CPU 资源的最小单位，线程模型分为 KLT 模型与 ULT 模型，JVM 使用的是 KLT 模型，Java 线程与 OS 线程保持 1:1 的映射关系，也就是说一个 Java 线程也会在操作系统里有一个对应的线程。Java 线程由多种生命状态 NEW：新建 RUNNABLE：运行 BLOCKED：
线程池解析
xiaoxishuaidaile的博客
11-07 110
1、线程池构造 public ThreadPoolExecutor(int corePoolSize, // 核心线程数 int maximumPoolSize,// 最大线程数 // 超过一段时间没运行的线程会被回收， // 如果配置了核心线程可以被回收，核心线程也可以被回收
JAVA基础知识五（多线程）
yuan_kk0321的博客
07-28 210
九、多线程 1.基本概念 程序：按照一定的逻辑编写的代码，存储到文件中，文件存放到磁盘---静态状态 进程：字面理解-正在进行中的程序。 资源：内存 + CPU 程序从启动到结束的过程叫做进程。 我们看到多个进程在同时执行的效果，实际上cpu在某一时刻只能执行其中一个进程 是因为cpu在做着高速的切换动作。 每个进程执行的时间也是不确定的，多个进程需要抢夺cpu的执行权。 线程：属于进程，是进程中一个可以独立运行执行单元(执行顺序，执行路径、代码片段)。 一个进程最少有一个线程。一个进程
线程的默认命名
weixin_33693070的博客
08-14 560
package service;import java.util.stream.IntStream;/** * @description: * @author: * @create: **/public class ThreadDefaultName { public static void main(String[] args) { IntStream.range(0, 5...
java修改线程池名称_自定义线程池的名称（ThreadPoolExecutor）
weixin_32941303的博客
02-25 4484
目的：有时候为了快速定位出现错误的位置，在采用线程池时我们需要自定义线程池的名称。1、创建ThreadFactory(ThreadPoolExecutor默认采用的是DefaultThreadFactory，可以参照代码)。public class NamedThreadFactory implementsThreadFactory{private final AtomicInteger pool...
多线程每个线程默认初始化模型_Java并发系列之Java多线程（一）
weixin_39520979的博客
12-10 163
前言文本已收录至我的GitHub仓库，欢迎Star：https://github.com/bin392328206/six-finger种一棵树最好的时间是十年前，其次是现在我知道很多人不玩qq了,但是怀旧一下,欢迎加入六脉神剑Java菜鸟学习群，群聊号码：549684836 鼓励大家在技术的路上写博客絮叨今天我们讲并发编程的基础，也就是多线程的基础，没有多线程的话，就没有并发对吧，下面...
一篇文章带你搞定在 Java 中取得和设置多线程名称
南淮北安的博客
01-16 1385
在 Thread 类中可以通过 getName() 方法取得线程的名称，还可以通过 setName() 方法设置线程的名称。 线程的名称一般在启动线程前设置，但也允许为已经运行的线程设置名称，允许两个 Thread 对象有相同的名称，但应该尽量避免这种情况的发生。 （1）在线程操作中，如果没有为一个线程指定一个名称，则系统在使用时会为线程分配一个名称，名称的格式为 Thread-Xx class ...
设置无标题 android
最新发布
05-02
在Android应用中，设置无标题是一种简洁和美观的设计方式，可以为用户提供更流畅的使用体验。以下是一些实现设置无标题的方法： 1. 在Android的Manifest文件中，找到对应Activity的标签，并添加”android:theme="@...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值