Java常用工具类---Java线程

最新推荐文章于 2022-09-19 17:07:40 发布
最新推荐文章于 2022-09-19 17:07:40 发布
阅读量247 收藏 1
点赞数
分类专栏： Java工程师
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwl755/article/details/105688994
版权

 

线程的创建

  • 创建一个Thread类，或者一个Thread子类的对象
  • 创建一个实现Runnable接口的类的对象

Thread是一个线程类，位于java.lang包下

Thread类的常用方法

Runnable接口

  • 只有一个方法run();
  • Runnable是Java中用以实现线程的接口
  • 任何实现线程功能的类都必须实现该接口

线程的创建

  • 通过继承Thread类的方式创建线程类，重写run()方法
  • 通过实现Runnable接口的方式创建
package com.imooc.thread1;
class MyThread extends Thread{
	public MyThread(String name){
		super(name);
	}
	public void run(){
		for(int i=1;i<=10;i++){
			System.out.println(getName()+"正在运行"+i);
		}
	}
}
public class ThreadTest {

	public static void main(String[] args) {
		MyThread mt1=new MyThread("线程1");
		MyThread mt2=new MyThread("线程2");
		mt1.start();
		mt2.start();
	}

}

 

package com.imooc.runnable;

class PrintRunnable implements Runnable {
	int i = 1;
	@Override
	public void run() {
		
		while (i <= 10)
			System.out.println(Thread.currentThread().getName() + "正在运行" + (i++));
	}

}

public class Test {

	public static void main(String[] args) {
		PrintRunnable pr = new PrintRunnable();
		Thread t1 = new Thread(pr);
		t1.start();
		//PrintRunnable pr1 = new PrintRunnable();
		Thread t2 = new Thread(pr);
		t2.start();

	}

}

线程的状态

  • 新建（New）
  • 可运行（Runnable）
  • 正在运行（Running）
  • 阻塞（Blocked）
  • 终止（Dead）

线程的生命周期

 

sleep方法应用

package com.imooc.sleep;

class MyThread implements Runnable {

	@Override
	public void run() {
		for (int i = 1; i <= 30; i++) {
			System.out.println(Thread.currentThread().getName() + "执行第" + i + "次！");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

public class SleepDemo {

	public static void main(String[] args) {
		MyThread mt = new MyThread();
		Thread t = new Thread(mt);
		t.start();
		Thread t1 = new Thread(mt);
		t1.start();
	}

}

 

join方法应用

package com.imooc.join;

class MyThread extends Thread{
	public void run(){
		for(int i=1;i<=500;i++)
		System.out.println(getName()+"正在执行"+i+"次！");
	}
}
public class JoinDemo {

	public static void main(String[] args) {
		MyThread mt=new MyThread();
		mt.start();
		try {
			mt.join(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		for(int i=1;i<=20;i++){
			System.out.println("主线程运行第"+i+"次！");
		}
		System.out.println("主线程运行结束！");
	}

}

 

线程优先级

package com.imooc.priority;

class MyThread extends Thread {
	private String name;

	public MyThread(String name) {
		this.name = name;
	}

	public void run() {
		for (int i = 1; i <= 50; i++) {
			System.out.println("线程" + name + "正在运行" + i);
		}
	}
}

public class PriorityDemo {

	public static void main(String[] args) {
		// 获取主线程的优先级
		int mainPriority = Thread.currentThread().getPriority();
		// System.out.println("主线程的优先级为："+mainPriority);
		MyThread mt1 = new MyThread("线程1");
		MyThread mt2 = new MyThread("线程2");
		// mt1.setPriority(10);
		mt1.setPriority(Thread.MAX_PRIORITY);
		mt2.setPriority(Thread.MIN_PRIORITY);
		mt2.start();
		mt1.start();
		// System.out.println("线程1的优先级为："+mt1.getPriority());
	}

}

 

同步--银行取款问题

package com.imooc.bank;

public class Bank {
	private String account;// 账号
	private int balance;// 账户余额

	public Bank(String account, int balance) {
		this.account = account;
		this.balance = balance;
	}

	public String getAccount() {
		return account;
	}

	public void setAccount(String account) {
		this.account = account;
	}

	public int getBalance() {
		return balance;
	}

	public void setBalance(int balance) {
		this.balance = balance;
	}

	@Override
	public String toString() {
		return "Bank [账号：" + account + ", 余额：" + balance + "]";
	}

	// 存款
	public synchronized void saveAccount() {

		// 获取当前的账号余额
		int balance = getBalance();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// 修改余额，存100元
		balance += 100;
		// 修改账户余额
		setBalance(balance);
		// 输出存款后的账户余额
		System.out.println("存款后的账户余额为：" + balance);
	}

	public void drawAccount() {
		synchronized (this) {
			// 在不同的位置处添加sleep方法

			// 获得当前的帐户余额
			int balance = getBalance();
			// 修改余额，取200
			balance = balance - 200;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			// 修改帐户余额
			setBalance(balance);
			System.out.println("取款后的帐户余额：" + balance);
		}

	}
}

package com.imooc.bank;
//取款
public class DrawAccount implements Runnable{
	Bank bank;
	public DrawAccount(Bank bank){
		this.bank=bank;
	}
	@Override
	public void run() {
		bank.drawAccount();
	}
	
}

package com.imooc.bank;
//存款
public class SaveAccount implements Runnable{
	Bank bank;
	public SaveAccount(Bank bank){
		this.bank=bank;
	}
	public void run(){
		bank.saveAccount();
	}
}

package com.imooc.bank;

public class Test {

	public static void main(String[] args) {
		// 创建帐户，给定余额为1000
		Bank bank = new Bank("1001", 1000);
		// 创建线程对象
		SaveAccount sa = new SaveAccount(bank);
		DrawAccount da = new DrawAccount(bank);
		Thread save = new Thread(sa);
		Thread draw = new Thread(da);
		save.start();
		draw.start();
		try {

			draw.join();
			save.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(bank);
	}

}

线程间通信

package com.imooc.queue;

public class Queue {
	private int n;
	boolean flag=false;
	
	public synchronized int get() {
		if(!flag){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("消费："+n);
		flag=false;//消费完毕，容器中没有数据
		notifyAll();
		return n;
	}

	public synchronized void set(int n) {
		if(flag){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("生产："+n);
		this.n = n;
		flag=true;//生产完毕，容器中已经有数据
		notifyAll();
	}
	
}

package com.imooc.queue;

public class Consumer implements Runnable{
	Queue queue;
	Consumer(Queue queue){
		this.queue=queue;
	}

	@Override
	public void run() {
		while(true){
			queue.get();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
}

package com.imooc.queue;

public class Producer implements Runnable{
	Queue queue;
	Producer(Queue queue){
		this.queue=queue;
	}

	@Override
	public void run() {
		int i=0;
		while(true){
			queue.set(i++);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}

}

package com.imooc.queue;

public class Test {

	public static void main(String[] args) {
		Queue queue=new Queue();
		new Thread(new Producer(queue)).start();
		new Thread(new Consumer(queue)).start();
	}

}

 

 

 

joker柒月
关注
专栏目录
java多线程-3（多线程工具类）
李歌
06-22 422
多线程工具类 1、CountDownLatch （倒计时锁存器） 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待 代码示例:使一个线程等待其他线程各自执行完毕后再执行 public class Demo{ public static void main(String[] args) throws InterruptedException{ CountDownLatch cdl = new CountDownLatch(3); fo
JAVA并发编程-2-线程并发工具类
01-20
JAVA并发编程-2-线程并发工具类一、Fork/Join1、分而治之与工作密取2、使用标准范式3、Fork/Join的同步用法4、Fork/Join的异步用法二、CountDownLatch三、CyclicBarrier四、Semaphore信号量五、Exchanger ...
7-Java常用工具类-多线程
weixin_34126557的博客
08-09 249
什么是线程？ 要理解线程，我们得从进程说起。 进程的概念: 进程是指可执行程序并存放在计算机存储器的一个指令序列,它是一个动态执行的过程。 我们程序员边听音乐边写代码再挂着qq，这三个软件可以同时运行就是我们的进程在起作用。 Windows的任务管理可以看到进程。一个软件可以多个进程。 早期我们的计...
java多线程工具类_Java多线程同步工具类之Semaphore
weixin_34171095的博客
02-25 120
Semaphore信号量通常做为控制线程并发个数的工具来使用，它可以用来限制同时并发访问资源的线程个数。一、Semaphore使用下面我们通过一个简单的例子来看下Semaphore的具体使用，我们同时执行10个计数线程，并定义一个Semaphore变量用来控制并发值，同一时间只允许两个线程并发执行；public static voidmain(String[] args) {Semaphore s...
Java 线程工具类
假装你是大灰狼的专栏
12-03 2432
1. CountDownLatch CountDownLatch首先定义任务次数，并调用await()方法等待任务完成。调用countDown()方法表明已经完成一项任务，当任务全部完成后，继续await()方法后的任务。 public class CountDownLatchThread extends Thread { CountDownLatch latch; publi...
Java多线程工具类
一名在校大三学习JAVA
07-17 1311
代码】Java多线程工具类。
java-java面试题库整理-基础-JVM-线程并发-框架等.zip
最新发布
02-06
为了在激烈的Java开发者竞争中脱颖而出，深入理解Java基础知识、JVM（Java虚拟机）、线程并发以及常用框架是至关重要的。这份"java-java面试题库整理-基础-JVM-线程并发-框架等.zip"文件提供了一个全面的复习资源，...
java常用工具类封装
09-14
"java常用工具类封装"是指将常见的功能如线程管理、数据解析、第三方库集成等进行封装，以提高代码的可重用性和可维护性。下面我们将深入探讨这些知识点： 1. **线程池**： Java中的线程池是由`java.util....
Java常用工具类
04-12
Java常用工具类是Java开发中不可或缺的一部分，它们提供了一系列便捷的方法，帮助开发者高效地处理各种常见任务。在Java中，最著名的工具类库是`java.util`包，它包含了大量实用类，如集合、日期时间、数学计算、...
java课件-5-多线程
01-10
Java提供了多种创建和管理线程的方法，包括实现Runnable接口和继承Thread类。实现Runnable接口更加灵活，因为它可以被多个线程共享，而继承Thread类则每个实例对应一个线程。 描述中的"java Concurrency"进一步强调...
java 线程工具类_java线程池工具类
weixin_33220713的博客
02-15 2447
import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;/*** 线程池基础类*/public class ThreadPoolUtil {/*** 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有...
java线程相关工具类
jikeyeka的博客
08-02 149
java线程相关工具类
java 多线程工具类_Java 多线程工具类
weixin_39762001的博客
02-19 233
notify waitwait()、notify()和notifyAll()是Object类中的native final方法(除重载)，这两个方法是为了解决多线程环境下的竞态环境，必须在同步方法块内调用notify,notifyAll 唤起其他等待锁的线程，但并不会立刻切换到其他线程，而是等到执行完同步代码块之后再进行切换，使用notify会唤起最先等待的线程，notifyAll会唤起所有等待的线...
Java多线程—常用并发工具类
ruan_luqingnian的博客
07-06 1724
java多线程—常用并发工具类java多线程—常用并发工具类CountDownLatchCyclicBarrierReadWriteLockSemaphoreExchanger java多线程—常用并发工具类 CountDownLatch CountDownLatch 倒计时锁存器 CountDownLatch countDownLatch = new CountDownLatch(3); await(),进入等待的状态 countDown(),计数器减一 应用场景：启动三个线程计
JAVA线程相关工具类
qq_35460634的博客
09-09 100
package com.project.common.utils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.concurrent.*; /** * 线程相关工具类. * * @author goln */ public class Threads { private static final Logger logger = LoggerFactory.getLogger(Th.
Java线程池工具类
weixin_44533129的博客
03-19 370
转载：https://blog.csdn.net/weixin_38399962/article/details/81979295 工具类 /** * Description:符合阿里巴巴规范的线程池 * User: zhouzhou * Date: 2019-01-15 * Time: 14:19 */ public class ThreadPoolUtil { public static ThreadPoolExecutor threadPool; /** * 无
Java线程工具类的使用
chordimp的博客
02-18 204
countDownLatch是一个线程计数器，具体使用代码如下 package com.tensquare.article.service; import java.util.concurrent.CountDownLatch; /** * @author haixin * @time 2020/2/12 */ public class UseCountDownLatch { ...
Java线程的并发工具类
故不积跬步无以至千里
09-19 835
CountDownLatch是在jdk1.5的时候引入的,位于java.util.concurrent并发包中,CountDownLatch叫做闭锁。CountDownLatch是一个同步工具类,它允许一个或多个线程一直等待,直到其它线程执行完后再执行。其作用是让一组线程到达公共屏障点时阻塞，直到最后一个线程也到达公共屏障点，屏障才会打开，而且该屏障（barrier）在这一组线程释放后可以重用，所以称为循环（Cyclic）的屏障（Barrier）。
java多线程工具类_Java多线程系列之：线程的并发工具类
weixin_26808963的博客
02-12 171
一，Fork-Join1，定义：Fork-Join框架：就是在必要的情况下，将一个大任务,进行拆分(fork)成若干个小任务(拆到不能再拆时)，再将一个个的小任务运算的结果进行join汇总。2，,Fork-Join体现了分而治之。什么是分而治之？规模为N的问题, 当N < 阈值,直接解决。当 N > 阈值, 将N分解为k个小规模子问题，子问题互相独立，与原问题形式相同。将子问题的解合并...
Java基础：进程与线程详解-多线程并发实践
在Java中，线程是通过继承Thread类或实现Runnable接口创建的。 **多线程应用示例**： 以"买票"为例，我们可以构建两个场景： 1. **单售票窗口**: 单线程场景下，每个购票请求会按照顺序排队等待处理，无法实现并行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值