小白学Java19：多线程

最新推荐文章于 2023-04-12 21:38:31 发布
最新推荐文章于 2023-04-12 21:38:31 发布
阅读量158 收藏 1
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44478196/article/details/106149203
版权

多线程

理解多线程

当我们打开了一个程序，就意味着在系统内部新建了一个进程，进程并不是程序执行的最小单位，每一个进程下面可能有很多线程，线程是实际CPU能够执行的最小单位

主线程

在Java程序启动时，一个线程立刻运行，该线程通常称为程序的主线程。

  • 主线程的重要性体现在两个方面：
    • 它是产生其他子线程的线程。
    • 通常它必须（除了守护线程之外）最后完成执行，因为它执行各种关闭动作。

注意

  • 主线程并不一定负责去关闭其他的子线程
  • 主线程并不一定是最后结束的（守护线程）

如何创建线程

方法1：创建类，使其继承Thread，并重写其中的run()方法

class MyThread extends Thread{
	public MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		System.out.println(this.currentThread().getName()+"：这是一条使用方法1创建的线程");
		System.out.println("此方法新建一个类，使其继承自Thread，并重写run()");
	}
}

//使用
MyThread myThread = new MyThread(“测试线程”);  //新建自定义线程类的实例对象
    myThread.start();   //开始执行线程

方法2：定义一个实现Runnable接口的实现类，实现run()方法

class MyRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println("这是一条使用方法2创建的线程");
		System.out.println("此方法新建一个类，使其实现Runnable接口，并重写run()");
	}
}

//使用
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable, "方法2");
thread.start();

方式3：定义一个实现Callable接口的实现类

class MyCallable implements Callable<Integer> {
	@Override
	public Integer call() throws Exception {
		System.out.println(Thread.currentThread().getName() + "：这是一条使用方法3创建的线程");
		System.out.println(Thread.currentThread().getName() + "：此方法新建一个类，使其实现Callable接口，并重写call()，且有返回值");
		System.out.println(Thread.currentThread().getName() + "：此线程正在计算数据:1+2+3+……+100");
		int x = 0;
		for (int i = 0; i < 100; i++) {
			x += i;

		}
		return x;
	}
}

//使用：
		MyCallable myCallble = new MyCallable();
		FutureTask<Integer> futrueTask = new FutureTask<Integer>(myCallble);

		System.out.println(Thread.currentThread().getName() + ":主线程正在运行");
		Thread callble = new Thread(futrueTask, "MyCallble");
		callble.start();
		Integer integer = futrueTask.get();
		System.out.println(Thread.currentThread().getName() + "：获取到子线程的运行结果：" + integer);

三种创建线程的区别：

  1. 实现Runnale接口可以避免你Java单继承特性而带来的局限；增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的，适合多个相同程序代码的线程去处理同一资源的情况，
  2. 继承Thread类和实现Runnable方法启动线程都是使用start方法，然后JVM虚拟机将此线程放到就绪队列中，如果有处理机可用，则执行Run方法；
  3. 实现Callable接口要实现call方法，并且线程执行完毕后会有返回值，其他的两种都是重写run方法，没有返回值
  4. 使用Thread创建线程，不能做到资源共享
//创建Thread继承
class MyThread1 extends Thread {
	int price = 10;
	@Override
	public void run() {
		while (true) {
			if (price > 0) {
				price--;
				System.out.printf(Thread.currentThread().getName() + ":正在售票,目前剩余%d\r", price);
			}
		}
	}
}

//测试使用
		MyThread1 thread = new MyThread1();
		thread.start();
		MyThread1 thread2 = new MyThread1();
		thread2.start();
//结果显示各卖各的票

//创建Runnable接口的实现类
class MyRunnable2 implements Runnable {
	int price = 10;

	@Override
	public void run() {
		while (true) {
			if (price > 0) {
				price--;
				System.out.printf(Thread.currentThread().getName() + ":正在售票,目前剩余%d\r", price);
			}
		}
	}
}
//测试使用
		MyRunnable2 runnable = new MyRunnable2();
		Thread thread1 = new Thread(runnable) ;
		Thread thread2 = new Thread(runnable) ;
		thread1.start();
		thread2.start();
		
//结果显示售卖同一份

Thread的重要方法

start（） ：启动线程
setPriority(int p): 设置线程的优先级
interrupt（）：有条件中断线程；
sleep（long s）：(static) 使线程睡眠让出CPU资源
current Thread（）：（static）获取当前正在执行的线程
isAliva（）：判断线程是否在活动状态
yield（）：让出CPU资源
setDaemon()：是否是守护线程；
join()：等待线程消亡

线程的状态：

  • 新建状态：线程对象被创建后，就进入了新建状态，例如：Thread thread = new Thread();
  • 就绪状态：也被称为可执行状态，线程对象被创建后，其他线程调用了该对象的Start()方法，从而来启动该线程，处于就绪状态的线程，随时可能被CPU调度执行
  • 运行状态：线程获取CPU权限进行执行，需要注意的是，线程只能从就绪状态进入到运行状态
    阻塞状态：阻塞状态是现成因为某种原因放弃CPU的使用权，暂时停止运行，直到线程进入就绪状态，才有机会转到运行状态，阻塞的情况分三种：
    1. 等待阻塞：通过调用线程的wait（）方法，让线程等待某工作的完成
    2. 同步阻塞：线程在获取synchronized同步锁失败（因为锁被其他线程所占用）塔会进入同步阻塞状态
    3. 其他阻塞：通过调用线程的sleep（）或发出了IO请求时，线程会进入到阻塞状态，当sleep（）状态超时，join（）等待线程终止或超市，或者IO处理完成时， 线程重新进入就绪状态
      死亡状态：线程执行完了或者因异常退出了run（）方法，该线程结束生命周期

线程的优先级

通过setPriority（），来设置线程的优先级，默认为5，最高为10，最低为1，优先级越高的线程更有机会获得CPU使用权

Mthread m1 = new Mthread("线程1");
Mthread m2 = new Mthread("线程2");

m1.setPriority(10);
m2.setPriority(1);

线程让步

yield（）：目前运行的线程让出CPU资源，然后重新竞争（效果不明显）

线程插队

线程使用join（）方法来进行线程插队

Thread mt = new Thread(){
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println(Thread.currentThread().getName()+"正在计数："+i);
				}
			};
		};
		mt.start();
		
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"正在计数："+i);
			if(i==3) {
				mt.join();
			}
		}
//main正在计数：0
//main正在计数：1
//main正在计数：2
//main正在计数：3
//Thread-0正在计数：0
//Thread-0正在计数：1
//Thread-0正在计数：2
//Thread-0正在计数：3
//Thread-0正在计数：4
//Thread-0正在计数：5
//Thread-0正在计数：6
//Thread-0正在计数：7
//Thread-0正在计数：8
//Thread-0正在计数：9
//main正在计数：4
//main正在计数：5
//main正在计数：6
//main正在计数：7
//main正在计数：8
//main正在计数：9

线程等待

  • wait()：当前线程调用wait()释放对象锁，进入等待状态
    • wait（long timeout):时间到了自动唤醒
  • notify()/notifyAll()唤醒等待的线程

生产者和消费者来理解wait()和notify()

public class Test {
	public static void main(String[] args) {
		Factory factory = new Factory();
		ProThread pro = new ProThread(factory);
		ConThread con = new ConThread(factory);
		pro.start();
		con.start();

	}
}
//创建工厂
class Factory{
	int num = 0;
	
//制造方法
	synchronized void set() {

		if (num == 10) {
			notify();
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
		num++;
		System.out.println("生产" + num);

	}
//消费方法
	synchronized void get() {

		if (num == 0) {
			notify();
			try {
				wait();

			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
		num--;
		System.out.println("消费" + num);

	}
}
//制造者线程类
class ProThread extends Thread {
	Factory factory;

	public ProThread(Factory factory) {
		this.factory = factory;
	}

	@Override
	public void run() {
		while (true) {
			factory.set();
		}
	}
}
//消费者线程类
class ConThread extends Thread {
	Factory factory;

	public ConThread(Factory factory) {
		this.factory = factory;
	}

	@Override
	public void run() {
		while (true) {
				factory.get();
		}
	}
}

守护线程

不是应用程序的核心部分：当后台只有守护线程在运行的时候，程序终止

设置守护线程

Thread thread = new Thread();
thread.setDaemon(true);

结束线程：

结束线程就是让线程的run方法执行完毕

方法1：修改标记

  • 使用于停止不阻塞的线程
    • 定义flag
      在run方法中使用while（flag），当修改flag的值时，停止线程
class ThreadTest extends Thread {
	boolean flag = true;

	void setFlag(boolean flag) {
		this.flag = flag;
	}

	public void run() {

		while (flag) {
			System.out.println("程序正在运行");
		}
	}
}
//测试
		ThreadTest thread = new ThreadTest();
		thread.start();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}

		thread.setFlag(false);
	}

方法2：使用isInterruoted()//返回线程是否中断

  • 适用于睡眠或等待中的线程
    • 同上，在while（this.isInterruoted())
      然后使用 interrupt（）方法就可以终止线程//中断该线程
		Thread thread = new Thread() {
			public void run() {
				while (!this.isInterrupted()) {
					System.out.println("此线程正在执行！");
				}
			};
		};
		thread.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		thread.interrupt();

线程同步

当两个或者多个线程需要访问统一资源的时候，他们需要以某种顺序来确保该资源某一时刻只能被一个线程使用的方式成为同步

实现同步

同步方法

synchronized关键字修饰的方法，称为同步方法

  • 当一个线程调用synchronized修饰的方法后，其他的线程必须等待此线程的结束才可以继续调用此方法
  • 测试：10万个人，每人给你1元钱，测试setMoney()方法，加synchronized关键字和不加的区别
class Bank {
	int money;

	public  void setMoney(int money) {
		this.money += money;
	}

	public int getMoney() {
		return money;
	}
}

class BankThread extends Thread {
	Bank bank;

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

	@Override
	public void run() {
		bank.setMoney(1);
		System.out.println(Thread.currentThread().getName() + "存入了1元，当前余额：" + bank.getMoney());
	}
}


测试：
		Bank bank = new Bank();

		for (int i = 0; i < 100000; i++) {
			BankThread test = new BankThread(bank);
			test.start();

		}

同步代码块

  • 锁住对象，用法:
synchronized(this){
    //代码
}
  • 也可以锁静态的方法,当一个线程访问synchronized修饰的static方法，其他线程就不能访问本类所有的synchronized static
static synchronized void add(){
    
}

锁的理解

可以同时访问的情况：

  • 情况1：一条线程调用有锁的静态方法，一条线程调用有锁的实例方法
  • 情况2：一条线程用实例a调用有锁的实例方法A，一条线程用实例b调用有锁的实例方法B
    • 锁实例方法：
      当锁实例方法时，锁住的时对象，所以如果有一条线程调用了该对象加锁的实例方法，其他线程就不能再用该对象调用此类下的所有加锁的实例方法，但是可以进入未加锁的实例方法
    • 锁静态方法：
      锁住的是类，当一条线程调用被锁住的静态方法时，其他线程将不能调用本类中其他加锁的静态方法，但是可以调用未加锁的静态方法

死锁

当两个线程同时执行，线程Xa进入了有锁的Fa，线程Xb进入了 有锁的Fb,当这个时候，Xa需要执行Fb,Xb需要执行Fa的时候，就发生了死锁

可重入锁

当一个线程调用加锁的Fa()的时候，如果Fa()内部或者接下来需要调用同一类的加锁的Fb（）,不需要继续获取锁

lock锁（lock是一个类，可以实现线程同步的效果）

lock锁可以判断线程有没有获得锁，必须手动释放

  • 常用方法:
新建方法：Lock lock =new ReentrantLock();

void lock（）//获取锁
void unlock() //释放锁

class A{
	Lock lock = new ReentrantLock();
	public void Fa() {
		lock.lock();
		System.out.println(Thread.currentThread().getName()+"获取了锁");
		System.out.println(Thread.currentThread().getName()+"正在执行Fa");
		System.out.println(Thread.currentThread().getName()+"释放锁");
		lock.unlock();}
}

boolean trylock()  //判断是否获取了锁
boolean trylock(int  ，time timeUnit)  //判断在某时间加单位内是否获取到了锁
void lockInterruotibly() 如果当前线程未中断，则获取锁，可以响应中断
Condition newCondition() 返回绑定到此lock实例的新condition实例
乌拉乌拉哩乌拉乌拉乌拉哩巴扎嘿！
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础学习(18)多线程
GUO_NULL192的博客
02-27 213
@TOC 一、基本概念 1.1 程序和进程的概念 程序 - 数据结构 + 算法，主要指存放在硬盘上的可执行文件。 进程 - 主要指运行在内存中的可执行文件。 目前主流的操作系统都支持多进程，为了让操作系统同时可以执行多个任务，但进程是重量级的，也就是新建一个进程会消耗CPU和内存空间等系统资源，因此进程的数量比较局限。 2.1 线程的概念 为了解决上述问题就提出线程的概念，线程就是进程内部的程序流，也就是说操作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是轻量的，新建线程会共享所在进程
JAVA多线程学习
Reanon的博客
11-11 420
JAVA 多线程笔记 参考狂神bilibli视频地址：https://www.bilibili.com/video/BV1V4411p7EF/ 一、基本概念 Process和Thread 程序：指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 进程：是执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位。 线程：CPU调度和执行的单位。 一个进程可以包含有多个线程（如视频中同时听到声音、看到图像，还可以看弹幕）；一个进程至少有一个线程，否则无存在的意义。 注意：很多多线程是
Lock的lockInterruptibly()方法
热门推荐
az44yao的专栏
03-27 1万+
lockInterruptibly()方法能够中断等待获取锁的线程。当两个线程同时通过lock.lockInterruptibly()获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。 示例： 要执行doBussiness()中的代码首先需要得到锁lock，线程使用lockInterruptibly()...
并发系列--Java中的各种锁
夏的专栏
08-14 275
Java中的各种锁 Lock接口 Lock简介，地位，作用 锁是一种工具，用于控制对共享资源的访问 Lock和Synchronized，这两个是最常见的锁，它们都可以达到线程安全的目的，但是在使用上和功能上又有较大的不同 Lock并不是用来代替synchronized的，而是当使用synchronized不合适或不满足要求的时候，来提供高级功能的。 Lock接口最常见的实现类是ReentraintLock 通常情况下，Lock只允许一个线程来访问这个共享资源。不过有的时候，一些特殊的实现也可允许并发访问，比
Java多线程学习
qq_33485630的博客
03-18 194
java多线程学习
Java多线程详解及示例
最新发布
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Concurrency:Java多线程学习
05-01
"Concurrency: Java多线程学习"这个主题涵盖了如何在Java中管理和利用多个执行线程，以实现并行处理，提高系统资源利用率，以及优化程序性能。 Java提供了一系列的并发工具和API，使得开发者可以安全地编写多线程...
MultiThreadExample:多线程示例 Java
06-30
在Java编程中，多线程是一项关键特性，它允许程序同时执行多个任务，提升系统效率和资源利用率。标题“MultiThreadExample:多线程示例 Java”表明我们将探讨...通过实际操作这些示例，对Java多线程的理解将更加深入。
JavaThread:Java线程
03-13
2. 线程优先级：Java提供了Thread类的setPriority()方法来设置线程优先级，但实际调度仍取决于操作系统的策略。 3. 线程睡眠：Thread.sleep()方法可以使当前线程暂停指定时间，释放CPU资源。 4. join()方法：让调用...
CoreJava:Java多线程
03-06
Java多线程是Java编程中的一个关键特性，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程可以通过两种主要方式实现：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当我们...
MySQL数据库中插入数据的几种方式
weixin_44478196的博客
04-14 814
insert into 最简单也是最基础的插入方式,传入List集合,然后在Sql语句中遍历取出 insert into `TableName`(field1,field2,field3,...) values <foreach item="item" index="index" collection="list" separator=","> ( #{item.value1}, #{item.value2}, #{item.value3}) </foreach&g
Nacos使用MySQL做持久化遇到的那些坑
weixin_44478196的博客
10-18 647
Nacos遇到的那些坑
【难题】VBox虚拟机使用NAT模式与真机互联互通的解决方案
weixin_44478196的博客
04-12 488
一直以来有一个问题，我的数据库装在虚拟机上，虚拟机之前一直使用的是桥接模式，有时候写些代码需要用到数据库的时候会造成一个很不方便的地方是，如果我在办公室，虚拟机可能是10.0.x.x的IP，这时候我的配置文件或者Navicat里数据库的IP都是10.0.x.x，办公室里没写完有的时候可能要带回家写，在家连上wifi之后，虚拟机的IP地址又变成了192.168.x.x，这样又要去改配置文件和Navicat的数据库地址了，这样真的很不方便；
小白学Java13：数学工具类：Math，高精度计算和数字格式化
weixin_44478196的博客
05-13 304
数学工具类：Math，高精度计算和数字格式化数学工具类：Math常用方法：随机数类：Random高精度计算类：DigDecimal构造方法常用方法关于小数的舍入模式数字格式化：NumberFormat构造方法常用方法自定义数字格式化类：DecimalFormat构造方法数字转字符串：format（）字符串转数字：parse() 数学工具类：Math Math 类包含基本的数字操作，如指数、对数、平方根和三角函数；Math中方法和常量都是静态的，因此可以通过类名直接调用 常用方法： 常用的方法: •sta
小白学Java22：MySQL
weixin_44478196的博客
06-14 254
MySQLMySQL的安装常见SQL语句创建数据库:展示数据库:修改数据库删除数据库查看当前使用的数据库使用数据库关于表格创建表格展示当前数据库下的所有表格打开表格详细信息删除表修改数据表的结构数据库中的约束常见的数据库约束==数据查询==基本查询1. 查询列2.查询所有列3.对列中的数据进行运算4.查询结果去重5.列的别名排序查询按照单列排序按照多列排序条件查询1. 等值判断(=) MySQL的安装 下载链接:https://dev.mysql.com/downloads/windows/install
小白学Java23：MySQL常用关键字和常用函数和各种约束
weixin_44478196的博客
06-16 251
MySQL关键字和常用函数常用关键字DQL：数据查询语言基础查询 SELECT _ FROM _AS: 给列自定义名称DISTINCT: 查询结果去重排序查询:ORDER BY条件查询:WHEREBETWEEN _ AND _ : 区间查询IS NOT NULL 和 IS NULLIN(_ ,_ , _): 枚举查询LIKE : 模糊查询CARE WHEN _ THEN _ :分支条件查询分组查询:GROUP BYHAVING: 分组过滤查询限定查询:LIMIT(分页查询)合并查询:UNION表连接查
小白学Java11：正则表达式
weixin_44478196的博客
05-13 241
正则表达式正则表达式定义正则表达式使用正则表达式基本语法：定位符基本语法：普通字符基本语法：转义字符基本语法：限定字符基本语法：或基本语法：通配符基本语法：方括号基本语法：简写基本语法：否定基本语法:() 正则表达式 正则表达式是通过模式匹配实现对字符的查询，提取，替换，分割;从而简化操作对字符的处理 定义正则表达式 String regex = "(正则表达式内容）"； 使用正则表达式 判断是否符合给定的正则表达式 boolean isMatches = str.matches(regex); 利
小白学Java18：IO流（下）：字节流，字符流，转换流和对象流
weixin_44478196的博客
05-14 232
字节流，字符流，转换流和对象流字节流父类：字节输入流和字节输出流低级流：文件字节流文件字节输入流：FileInputStream文件字节输出流：FileOutputStream高级流：缓冲字节流字节缓冲输入流：BufferedInoutStream字节缓冲输出流：BufferedOutoutStream使用缓冲流来实现文件的复制字符流父类：字符输入流和字符输出流文件字符输入流：FileReader：继承自InputStreamReader文件字符输出流：FileWriter：继承自OutputStreamW
小白学Java05：面向对象的特性1：封装（包和访问权限）
weixin_44478196的博客
05-11 227
面向对象的特性1：封装（包和访问权限）封装的定义包包的定义包的声明方式访问控制publicprotected(默认，前边没有修饰字的情况)private 封装的定义 将数据连同函数捆绑在一起，形成新的类型，这被称为封装。 java语言中，对象就是对一组变量和相关方法的封装，其中变量表明了对象的状态，方法表明了对象具有的行为。 通过对象的封装，实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限，实现了类中成员的信息隐藏。 包 包的定义 包(package)是类的容器，用来保存划分类名空间。 由于J
Java基础：多线程原理与创建方法详解
Java基础之多线程是计算机编程中的核心概念，尤其是在并发编程领域，它允许程序同时执行多个任务或操作，从而提高系统的效率和响应能力。本文将深入探讨Java中的多线程实现以及其重要性。 **1. 线程简介** 多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值