Java常用工具_5.Java线程

最新推荐文章于 2024-07-04 09:24:51 发布
最新推荐文章于 2024-07-04 09:24:51 发布
阅读量169 收藏
点赞数 1
分类专栏： java基础 文章标签： 多线程 java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45316053/article/details/107581726
版权

Java常用工具_5.Java线程

一、线程

1.进程

进程是指可执行程序并存放在计算机存储器的一个指令序列，它是一个动态执行的过程
有些软件对应一个进程，有些软件由多个进程组成

2.什么是线程？

线程是比进程还要小的运行单位，一个进程包括多个线程
线程可以看作一个子程序

3.软件同时运行？

对于CPU来说，许多软件是轮流运行的，但是由于时间间隔非常短，所以用户会感觉软件是同时运行的

二、线程的创建

1.创建方式

(1)创建一个Thread类,或者一个Thread子类的对象
(2)创建一个实现Runnable接口的类的对象

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

Thread构造方法
在这里插入图片描述
Thread类的常用方法
在这里插入图片描述

3.Runnable接口

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

4.通过Thread类创建线程：重写run()方法

package com.study.thread;

class MyThread extends Thread {
	public void run() {
		System.out.println(getName() + "该线程正在执行!");
	}
}

public class ThreadTest {

	public static void main(String[] args) {
		System.out.println("主线程1");
		MyThread mt = new MyThread();
		mt.start();// 启动线程,会执行run()的代码
		// 线程是不能多次启动的,即只能调用一次start()方法
		System.out.println("主线程2");
//		主线程1
//		主线程2
//		Thread-0该线程正在执行!

	}

}


package com.study.thread1;

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

	public void run() {
		for (int i = 0; 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();
		// 线程获得cpu的使用权是随机的，所以运行顺序也是随机的
	}

}

5.通过实现Runnable接口的方式创建线程

为什么要实现Runnable接口?

  • Java不支持多继承
  • 不打算重写Thread类的其他方法
package com.study.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();

	}

}

三、线程的状态和生命周期

1.线程的5个状态

(1)新建（New)
(2)可运行(Runnable)(也称就绪)
(3)正在运行(Running)
(4)阻塞(Blocked)
(5)终止(Dead）

2.线程的生命周期

在这里插入图片描述

四、sleep方法(Runnable→Blocked)

1.Thread类的方法

public static void sleep(long millis)

2.作用

在指定的毫秒数内让正在执行的线程休眠(暂停执行)

3.参数为休眠的时间,单位是毫秒

4.代码实现

package com.study.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方法(Runnable→Blocked)

1.Thread类的方法

public final void join();

2.作用

等待调用该方法的线程结束后才能执行(抢占资源)

3.public final void join(long millins)

等待该线程终止的最长时间为millis毫秒.
如果millis为0则意味着要一直等下去.

4.代码实现

package com.study.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(2);// 等待该线程终止的最长时间为2ms
			// mt.join();// 抢占资源，其他线程会等待该方法的线程执行结束后才执行
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		for (int i = 1; i <= 20; i++) {
			System.out.println("主线程运行第" + i + "次");
		}
		System.out.println("主线程运行结束!");
	}

}

六、线程优先级

1.线程的优先级

(1)Java为线程类提供了10个优先级
(2)优先级可以用整数1-10表示,超过范围会抛出异常
(3)主线程默认优先级为5

2.优先级常量

MAX_PRIORITY：线程的最高优先级10
MIN_PRIORITY：线程的最低优先级1
NORM_PRIORITY：线程的默认优先级5

3.优先级相关的方法

在这里插入图片描述

4.代码实现

package com.study.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);// 设置线程1的优先级为10
		// mt1.setPriority(Thread.MAX_PRIORITY);
		mt2.setPriority(1);
		mt2.start();
		mt1.start();
		// System.out.println("线程1的优先级为" + mt1.getPriority());
	}

}

七、线程同步

1.多线程运行问题

• 各个线程是通过竞争CPU时间而获得运行机会的
• 各线程什么时候得到CPU时间,占用多久,是不可预测的
• 一个正在运行着的线程在什么地方被暂停是不确定的

2.银行存取款问题

为了保证在存款或取款的时候,不允许其他线程对帐户余额进行操作，需要将Bank对象进行锁定
使用关键字synchronized实现

3.同步

synchronized关键字用在 成员方法、静态方法、语句块

4.银行存取款系统代码实现

package com.study.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() {
		// 可以在不同的位置处添加sleep方法
		// 获取当前的账户余额
		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("存款100元后的账户余额：" + 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("取款200后的账户余额：" + balance);
		}
	}
}


package com.study.bank;

//取款
public class DrawAccount implements Runnable {
	Bank bank;

	public DrawAccount(Bank bank) {
		this.bank = bank;
	}

	@Override
	public void run() {
		bank.drawAccount();
	}

}


package com.study.bank;

//存款
public class SaveAccount implements Runnable {
	Bank bank;

	public SaveAccount(Bank bank) {
		this.bank = bank;
	}

	public void run() {
		bank.saveAccount();
	}
}


package com.study.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);
	}

}

八、线程间通信

1.问题：帐户余额不够了怎么办?

等待存入足够的钱后处理

2.等待和唤醒方法

wait()方法：中断方法的执行,使线程等待
notify()方法：唤醒处于等待的某一个线程,使其结束等待
nofifyAll()方法：唤醒所有处于等待的线程,使它们结束等待

3.生产者消费者代码实现

package com.study.queue;

public class Queue {
	private int n;
	boolean flag = false;// false：Queue中没有数据,生产数据后flag变为true，此时可以消费

	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.study.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.study.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.study.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();
	}

}
郝穹
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程检测和数据收集工具
11-03
通过jps 和jstack定时收集java进程的线程信息
java多线程常见工具类
qq_50523945的博客
05-30 1493
CountDownLatch使用执行结果打印。
Java基础---多线程Thread，Component
ding630345720的博客
06-26 1197
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 一、多线程Thread： 1、程序中的执行线程。在Java 虚拟机允许应用程序同时运行多个执行线程。 创建线程的3种方式： (1)方式1:继承Thread类 A: 创建自定义类，继承于 Thread B: 在自定义类中，
Java线程池之栅栏
大逗的博客
12-17 1469
 通过闭锁来启动一组相关的操作，或者等待一组相关的操作结束。闭锁是一次性对象，一旦进入终止状态，就不能重置。  栅栏类似于闭锁，它能阻塞到一组线程到某个事件发生。栅栏于闭锁的关键区别在于，所有线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。栅栏用于实现一些协议，例如几个家庭决定在某个地方集合：”所有人6:00在麦当劳碰头，到了以后要等待其他人，之后再讨论下一步要做...
java 线程监控工具_JDK自带的线程监视工具jvisualvm
weixin_36018773的博客
02-12 1571
一.Java VisualVM 概述对于使用命令行远程监控jvm太麻烦。在jdk1.6中Oracle提供了一个新的可视化的。JVM监控工具JavaVisualVM。jvisualvm.exe在JDK的bin目录下。双击启动JavaVisualVM后可以看到窗口左侧“应用程序”栏中有“本地”、“远程”、“快照”三个项目。“本地”下显示的是在loc...
java_exam_01.rar_java 考核
09-23
9. **Java标准库**：了解并能熟练使用常用的Java内置库，如Math类，Date和Calendar类，集合框架等。 考生还应熟悉Java开发工具，如Eclipse或IntelliJ IDEA，以及版本控制系统如Git。此外，理解Maven或Gradle构建...
java_ttplayer_src.rar_java_ttplayer_src
09-19
5. **文件I/O操作**：为了加载音频文件，需要熟悉Java的File和InputStream类，以及如何处理不同音频格式（如MP3、WAV等）。 6. **事件处理**：用户交互，如点击播放/暂停按钮，需要通过监听事件来响应。Java GUI库...
Java_practice_answer.rar_java practi_java 习题_practice
09-23
这些都是Java开发中常用且重要的概念，对于实际项目开发非常实用。 在实践中，了解并应用设计模式也是提高代码质量和可维护性的重要环节。例如，单例模式、工厂模式、观察者模式、装饰器模式等，都是Java开发者应该...
java_basic_examinations.rar_java pdf_java基础
09-14
11. **多线程**：Java支持并发编程，可以创建线程并管理它们，以提高程序的执行效率。 12. **文件和目录操作**：Java的File类允许对文件和目录进行创建、删除、重命名等操作。 13. **反射机制**：反射允许程序在...
QQ_Java.zip_QQ java
09-20
JUnit是Java常用的单元测试框架，而IDE的调试工具则帮助开发者定位和修复问题。 通过这个项目，开发者不仅可以学习到Java编程的基本技巧，还能深入理解网络通信、多线程、数据库操作以及用户界面设计等多个方面的...
实现线程的方式到底有几种？
Java烂猪皮
09-19 1409
走过路过不要错过点击蓝字关注我们这篇文章主要讲解实现线程的方式到底有几种？以及实现 Runnable 接口究竟比继承 Thread 类实现线程好在哪里？实现线程是并发编程中基础中的基础，...
java 线程 显示窗口_java查看当前项目所有线程列表界面【转】
weixin_39989443的博客
02-13 137
packagecom.isoftstone.pcis.isc.job.king.panel;import java.awt.*;import java.lang.reflect.*;import javax.swing.*;import javax.swing.table.*;public class ThreadViewerTableModel extendsAbstractTableModel...
Java多线程常用工具小结
笨小孩的专栏
08-15 228
Java多线程问题常用的几种场景（不是全部）通常需要包括如下几个方面：   共享资源的互斥访问（比如：资源初始化过程）。 有限资源的访问控制（比如：数据库连接池会限制只有有限个线程可以同时保持链接）。 多线程之间访问的通讯配合（比如：典型的生产-消费模式场景） 构建线程池 Callable &amp; Future 读过写少的并发控制（比如：资源初始化过程）。 针对这些比较典型...
java 窗口线程_Java 窗体与线程问题
weixin_34178408的博客
02-19 131
展开全部主窗口线程不能阻塞，也就是说应该处于空闲状态。如果阻62616964757a686964616fe4b893e5b19e31333335333638塞，窗口将不能响应用户事件。程序应该类似于这样publicclassServerFrameextendsJFrame{publicServerFrame(){//设置其他窗口参数//设置标签：运行中newListenerThre...
查看java线程cpu使用高的工具
十个菜
08-05 446
git clone git://github.com/oldratlee/useful-scripts.git cd useful-scripts # 使用Release分支的内容 git checkout release # 更新脚本 git pull 下载单个文件 wget --no-check-certificate https://raw.github.com/oldratlee/useful-scripts/release/show-busy-java-threads chmod +.
java swing 使用菜单-使用线程-以简单计时器为例
学者的博客
06-27 385
swing 这是一个在swing下使用线程的例子。 本例演示了如何在swing中使用菜单。 因为，swing界面是单线程的。所以如果有其它逻辑，例如从网络异步获得数据等等都需要开其它线程。否则会影响到界面。 例子 代码 package timer; import java.awt.*; import java.awt.RenderingHints.Key; import java.awt.ev...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1235
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 510
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
最新发布
Casual_Lei的博客
07-04 631
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
Java多线程（Synchronized+Volatile+JUC 并发工具原理+线程状态+CAS+线程池）
06-21
在Java中，常用的多线程技术包括Synchronized、Volatile、JUC（Java Util Concurrent）并发工具等。这些技术可以帮助程序员更好地管理多线程，保证程序的正确性和效率。其中，Synchronized是一种重要的同步机制，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值