day18_java多线程编程

最新推荐文章于 2022-10-19 19:50:01 发布
最新推荐文章于 2022-10-19 19:50:01 发布
阅读量231 收藏 1
点赞数
分类专栏： javase复习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24135817/article/details/80557765
版权

线程

基本概念

进程：内存中正在进行的一个程序

线程：进程中的一个执行流程

多线程：有两个 或者 两个以上并发的执行流程

线程的生命周期，线程分为以下五种状态

  • （新建） New Thread();
  • （就绪） start();
  • （运行） run();
  • （阻塞） 暂停执行

    • sleep（就像我们做总结睡着了），join（让其他人先做，就像做总结时中间让其他人讲话)阻塞

      sleep：等待多少毫秒；超过了之后回复就绪状态等待cpu调用执行
      join：等待其他线程执行完，线程A调用了线程B的join（）；方法，那么线程A等线程B执行完再执行

    • 同步（排队）

    • wait（晕过去了）

  • （死亡）

线程图解：

这里写图片描述

主线程

当Java程序启动时，一个线程立刻运行，该线程通常叫做程序的主线程（main thread），它是程序开始时就执行的。

主方法就是主线程的任务 main（）；

public class TestThreadMain {

	public static void main(String[] args) {
		// 获得当前的线程                      主线程名字,优先级,主线程组
		System.out.println(Thread.currentThread());//Thread[main,5,main]
		System.out.println(Thread.currentThread().getName());//main


	}

}

问题：启动一个java应用程序至少启动几个主线程？

会先启动两个线程：一个主线程，一个垃圾回收线程

子线程

默认的名字：Thread —— 数字

创建子线程

  • 方式一：继承自Thread类
  • 方式二：实现Runnable 接口

区别：

  1. 继承Thread类，继承了Thread类的所有可以继承的；Runnable接口，只有run（）；
  2. Runnable接口有利于资源共享

希望主线程最后结束

  1. sleep() 暂停多长时间
  2. isAlive() 判断线程仍在运行，isAlive()方法返回true，如果不是则返回false。
  3. join() 等待一个线程执行完

/** 创建子线程示例代码 */

//创建子线程方法一：继承自Thread类  
class MyThread extends Thread{
	MyThread(String name){
		super(name);
	}

	//子线程的任务功能在run中
	@Override
	public void run() {
		for(int i = 1; i<= 3 ; i++){
			System.out.println(Thread.currentThread().getName() +":"+i);
		}
	}
	
}


//创建子线程方法二：实现Runnable 接口    用的较多，有利于资源共享
class ThreadDemo implements Runnable{

	@Override
	public void run() {
		for(int i = 1; i<= 3 ; i++){
			System.out.println(Thread.currentThread().getName() +"吃饭");
		}
		
	}
}

public class TestThread1 {

	public static void main(String[] args) {
//		//创建一个线程对象
//		Thread t = new Thread();
//		//启动线程
//		t.start();
		
//		//创建一个子线程
//		MyThread t1 = new MyThread("t1");//新建
//		//启动子线程，必须用start，并且只能启动一次
//		t1.start();//就绪
		
		
		//不是线程对象
		ThreadDemo demo = new ThreadDemo();
		//                     绑定ThreadDemo类对象
		//Thread zhangsan = new Thread(demo);
		Thread zhangsan = new Thread(demo,"张三");
		Thread lisi = new Thread(demo,"李四");
		

		//设置优先级
		/*	lisi.setPriority(10);
		zhangsan.setPriority(1);*/
		//最低，普通，最高        比直接赋予数字好一些
		//1   5   10
		zhangsan.setPriority(Thread.MAX_PRIORITY);
		zhangsan.setPriority(Thread.MIN_PRIORITY);
		zhangsan.setPriority(Thread.NORM_PRIORITY);
		
		//启动线程
		zhangsan.start();
		lisi.start();
		
		//希望主线程最后结束方法一
	/*	try {
			Thread.sleep(1000);//等1000毫秒
		} catch (InterruptedException e) {
			e.printStackTrace();
		}*/
		希望主线程最后结束方法二：判断子线程是否运行
/*		if(zhangsan.isAlive() || lisi.isAlive()){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}*/
		
	//希望主线程最后结束方法三：让子线程都执行完才能恢复主线程
		try {
			zhangsan.join();
			lisi.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("主线程结束");
		

	}

}

线程优先级

1 – 10

10最高

  • 理论上，优先级高的线程比优先级低的线程获得更多的CPU时间
  • 实际上，线程获得的CPU时间通常由包括优先级在内的多个因素决定
  • 理论上，等优先级线程有同等的权利使用CPU
/** 创建子线程 */

//创建子线程方法一：继承自Thread类  
class MyThread extends Thread{
	MyThread(String name){
		super(name);
	}

	//子线程的任务功能在run中
	@Override
	public void run() {
		for(int i = 1; i<= 3 ; i++){
			System.out.println(Thread.currentThread().getName() +":"+i);
		}
	}
	
}

//创建子线程方法二：实现Runnable 接口用的较多，有利于资源共享
class ThreadDemo implements Runnable{

	@Override
	public void run() {
		for(int i = 1; i<= 3 ; i++){
			System.out.println(Thread.currentThread().getName() +"吃饭");
		}
		
	}
}

public class TestThread1 {

	public static void main(String[] args) {
//		//创建一个线程对象
//		Thread t = new Thread();
//		//启动线程
//		t.start();
		
//		//创建一个子线程
//		MyThread t1 = new MyThread("t1");//新建
//		//启动子线程，必须用start，并且只能启动一次
//		t1.start();//就绪
		
		
		//不是线程对象
		ThreadDemo demo = new ThreadDemo();
		//                     绑定ThreadDemo类对象
		//Thread zhangsan = new Thread(demo);
		Thread zhangsan = new Thread(demo,"张三");
		Thread lisi = new Thread(demo,"李四");
		

		//设置优先级
		/*	lisi.setPriority(10);
		zhangsan.setPriority(1);*/
		//最低，普通，最高        比直接赋予数字好一些
		//1   5   10
		zhangsan.setPriority(Thread.MAX_PRIORITY);
		zhangsan.setPriority(Thread.MIN_PRIORITY);
		zhangsan.setPriority(Thread.NORM_PRIORITY);
		
		//启动线程
		zhangsan.start();
		lisi.start();
		
		//希望主线程最后结束方法一
	/*	try {
			Thread.sleep(1000);//等1000毫秒
		} catch (InterruptedException e) {
			e.printStackTrace();
		}*/
		希望主线程最后结束方法二：判断子线程是否运行
/*		if(zhangsan.isAlive() || lisi.isAlive()){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}*/
		
	希望主线程最后结束方法三：让子线程都执行完才能恢复主线程
		try {
			zhangsan.join();
			lisi.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("主线程结束");
		

	}

}

线程其它方法

interrupt()线程中断 ：sleep()和join()

**问题:**java线程什么时候会引发InterruptedException ?

前提：当前线程处于sleep或者join时，被其他线程中断了，那么当前线程会进行异常处理

class ThreadDemo1 implements Runnable{

	@Override
	public void run() {
		for(int i = 1 ; i <=5 ; i++){
			System.out.println(Thread.currentThread().getName()+","+i);
			if(i == 3){	
				try {
					//Thread.sleep(1000);
					Thread.currentThread().join();
				} catch (InterruptedException e) {
					System.out.println("进入异常处理了");
				//	e.printStackTrace();
				}
			}
		}
		
		
	}
	
}

public class TestThreadInterrupt {

	public static void main(String[] args) {
		ThreadDemo1 demo1 = new ThreadDemo1();
		Thread t1 = new Thread(demo1);
		t1.start();
		//主线程调用了子线程t1的interrupt方法，子线程t1被中断进入异常处理
		t1.interrupt();

	}

}

yield() 线程让步 （了解即可，现在基本不用）：

Thread.yield()：不能完全保证线程让步

class ThreadDemo1 implements Runnable{

	@Override
	public void run() {
		for(int i = 1 ; i <=5 ; i++){
			System.out.println(Thread.currentThread().getName()+","+i);
			if(i == 3){	
				try {
					//Thread.sleep(1000);
					Thread.currentThread().join();
				} catch (InterruptedException e) {
					System.out.println("进入异常处理了");
				//	e.printStackTrace();
				}
			}
		}
		
		
	}
	
}

public class TestThreadInterrupt {

	public static void main(String[] args) {
		ThreadDemo1 demo1 = new ThreadDemo1();
		Thread t1 = new Thread(demo1);
		t1.start();
		//主线程调用了子线程t1的iterrupt方法，子线程t1被中断进入异常处理
		t1.interrupt();

	}

}

线程的同步

什么是同步

某一时刻此资源只能被一个线程独占。
线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。

为什么使用同步

当两个或两个以上的线程需要共享资源，他们需要某种方法来确定资源在某一时刻仅被一个线程占用，达到此目的的过程叫做同步。（某一时刻资源只能被一个线程独占）

使用同步
  1. 同步代码块
    我们可以将对某个方法的调用放入一个synchronized块内
synchronized(对象){ 
 
 同步块； 
 
}
  1. 同步方法，锁的是对象 this
synchronized  方法{   } 

/**同步示例代码*/
class Bank implements Runnable{
	int money = 0;
	//存钱
	//同步方法
	synchronized public void setMoney(){
		money += 100;//存100
		System.out.println(Thread.currentThread().getName() + "存了100,余额：" +money);
	}
	@Override
	public void run() {
		for(int i = 0 ; i < 3 ; i++){
			//同步锁
			//同步块
/*			synchronized(this){
			setMoney();
			}*/
			setMoney();
		}
		
	}
	
}
public class TestBank {

	public static void main(String[] args) {
		Bank bank = new Bank();
		Thread zhangsan = new Thread(bank,"zhangsan");
		Thread lisi = new Thread(bank,"lisi");
		zhangsan.start();
		lisi.start();
	}

}

Lock

优势

可以显示加锁，释放锁

获得锁：

当一个线程访问此对象的同步块或同步方法的时候，
申请同步锁，申请成功了，就获得了锁。在执行同步块
和同步方法的过程中，其它线程进入线程锁定池中处于
阻塞状态。只有当前执行锁的线程释放了锁其它线程
才有机会获得CPU的调用执行。

释放锁：

1.同步方法或同步块中的代码正常执行完了，就释放了；
2. 出现了未处理的异常Exception和
Error时 ，释放锁；
3. break,return语句，会结束方法或
代码块，那么会释放锁。
4. 执行了 wait()会释放锁。

语法：
try{  
    加锁lock 
    
}finally{   
    释放unLock 
    
}
lock作用
  1. 可以显示加锁和释放锁
  2. 提供了更多功能
死锁
  • 每个对象只有一个锁（lock）不之相关联
  • 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制
/**死锁示例代码 */
class Zhangsan{
	public void say(){
		System.out.println("你给我书，我就给你画");
	}
	public void get(){
		System.out.println("张三获得了书");
	}
}

class Lisi{
	public void say(){
		System.out.println("你给我画，我就给你书");
	}
	public void get(){
		System.out.println("李四获得了画");
	}
}
class LockDemo implements Runnable{
	static Zhangsan zhangsan = new Zhangsan();
	static Lisi lisi = new Lisi();
	boolean tag ;
	
	@Override
	public void run() {
		if(tag == true){//张三
			synchronized(zhangsan){
			zhangsan.say();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			synchronized(lisi){
				zhangsan.get();
			}
			}
		}else{//李四
			synchronized(lisi){
				lisi.say();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				synchronized(zhangsan){
					lisi.get();
				}
			}
		}
		
	}
	
}
public class Testlock {

	public static void main(String[] args) {
		LockDemo demo1 = new LockDemo();
		demo1.tag = true;
		LockDemo demo2 = new LockDemo();
		demo2.tag = false;
		Thread t1 = new Thread(demo1);
		Thread t2 = new Thread(demo2);
		t1.start();
		t2.start();
	}

}

wait（）和sleep的区别：

  • 区别：
  • 时间参数
    • wait()可以可定时间也可以不指定； sleep()必须指定时间；
  • 同步状态
    • sleep()释放执行权，不释放锁 ；wait释放执行权，释放锁
class Show implements Runnable{
	int i = 10 ;
	@Override
	synchronized public void run() {
		for(; i >= 0 ; i--){
			
			if(i == 5  && Thread.currentThread().getName().equals("t1:")){
				try {
					//Thread.sleep(100000);
					wait(1000);
					System.out.println("我醒了");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+i);
		}	
		
	}
	
}

public class Exercise1 {

	public static void main(String[] args) {
		Show sh = new Show();
		Thread t1 = new Thread(sh,"t1:");
		Thread t2 = new Thread(sh,"t2:");
		t1.start();
		t2.start();

	}

}

包子铺实例理解wait（）、notify（）

package day26;
class QingFeng {
	private int count;//包子数量
	private boolean tag = false;//true ->有包子，false->没包子

	public int getCount() {
		return count;
	}
	public void setCount(int count) {
		this.count = count;
	}
	
	//生产包子
	synchronized public void put(int count){
		//有包子，休息
		if(tag == true){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//没有包子 false
		this.count = count;
		System.out.println("生产了" +this.count);
		tag = true;
		notify();//唤醒销售
	}
	//销售包子
	synchronized public void get(){
		//没包子可卖，休息一会
		if(tag == false){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// 有包子true
		System.out.println("卖了" +this.count);
		tag = false;//卖完了
		notify();//唤醒厨师
	}

}
//生产
class Producer implements Runnable{
	QingFeng qingfeng;
	

	public Producer(QingFeng qingfeng) {
		super();
		this.qingfeng = qingfeng;
	}


	public Producer() {
		super();
	}


	@Override
	public void run() {
		//生产
		for(int i = 1 ; i <=5 ; i++){
			qingfeng.put(i);
		}
	}
	
}

//销售
class Consumer implements Runnable{
	QingFeng qingfeng;
	
	public Consumer() {
		super();
	}

	public Consumer(QingFeng qingfeng) {
		super();
		this.qingfeng = qingfeng;
	}

	@Override
	public void run() {
		for(int i = 1 ; i <= 5 ; i++){
			qingfeng.get();
		}
	}
	
}

public class Exercise2 {

	public static void main(String[] args) {
		QingFeng qingfeng = new QingFeng();
		Producer pro = new Producer(qingfeng);
		Consumer con = new Consumer(qingfeng) ;
		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(con);
		t1.start();
		t2.start();

	}

}
戴戴0204
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程并发上传实例_多线程 网络编程 文件上传案例多线程
weixin_33509203的博客
02-26 1220
Day13 多线程3).多线程的好处：提高程序的运行效率，提高用户的体验度。 线程不会因为等待某个资源而进入等待状态创建新的线程:* 定义类继承Thread* 重写方法run* 创建Thread子类的对象* 调用子类对象的方法start()** 为什么继承Thread* Thread类是线程对象类* 继承了Thread,子类也是线程对象** 为什么重写run...
java多线程编程
qq_44045519的博客
06-12 1126
多线程简介 对多线程的理解 1. 多任务与多线程  　　多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。 2. 多线程例子(生活，游戏，编程) 边吃饭边玩手机，边听歌边写作业 开黑打游戏 等等 3. 进程，程序，线程的理解 进程: 是程序的一次执行，是动态的，一个进程至少包含一个线程，一个线程不能独立存在,它必须是进程的一部分；一个进程一直运行，直到所有非守护线程都结束运行后才能结束。 程序是代码段，是静态的。 一条线程指的是进程中一个单一顺序的控制流，一
Java多线程编程
最新发布
chenmi123321的博客
10-19 1005
java
多线程抢票_java多线程下模拟抢票
weixin_39672160的博客
01-13 877
我们设置三个对象分别同时抢20张票,利用多线程实现.public class Web123506 implements Runnable{private int ticteksNums=20;//票数@Overridepublic void run() {while (true){if(ticteksNums<0){break;}/* try {//睡眠Thread.sleep(200);}...
Java 多线程编程
红叶岭谷的博客
05-12 467
Java 多线程编程 Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程，并且每个线程定义了一个独立的执行路径。 多线程是多任务的一种特别的形式。多线程比多任务需要更小的开销。 这里定义和线程相关的另一个术语：进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。
day02_eesy_01anno_ioc_多线程_
10-02
本课程“day02_eesy_01anno_ioc_多线程”主要聚焦于Spring框架的核心特性——IOC（Inversion of Control，控制反转）以及其在多线程环境下的应用。 首先，让我们深入理解什么是IOC。控制反转是一种设计模式，它将...
day0905qq.zip_网络编程_Java_
08-11
心跳机制通常结合多线程编程，确保即使在无数据交换时，连接也不会因超时而断开。 总的来说，"day0905qq.zip"项目涵盖了Java网络编程的多个方面，包括TCP连接、SWING GUI设计、文件传输以及状态同步。通过这个项目...
day13_StringBuffer_java_
10-03
在Java编程语言中，"StringBuffer" 是一个非常重要的类，尤其在处理字符串操作时，尤其是在多线程环境中。在本教程"day13_StringBuffer_java_"中，我们将深入探讨这个类及其在Java中的作用。 Java是C++的优化版本，...
day15_多线程02.zip
09-12
总的来说，"day15_多线程02"的学习内容可能涵盖了上述多线程编程的各个方面，包括线程的创建、同步、线程安全、线程池以及问题诊断。通过深入理解和实践，你可以提升你的并发编程技能，更好地应对复杂系统的设计和...
day14_多线程01.zip
09-12
在多线程编程中，需要关注的主要问题包括线程安全和同步。线程安全指的是当多个线程访问同一资源时，不会产生错误或不一致的状态。为确保线程安全，可以使用同步机制，如锁（互斥锁、读写锁）、信号量、条件变量等。...
List和数组的转换
戴戴的博客
08-20 2956
package dataproject; import java.util.Arrays; import java.util.List; public class TestArray { public static void main(String[] args) { //String[]数组转String类型的集合，当需要使用int，double等集合的时候，需要...
day10_java抽象类，接口，多态，uml类图
戴戴的博客
05-21 1570
抽象类 只约定类所具有的抽象行为，没有具体实现相应的行为 为什么要使用抽象类 有时候子类不需要抽象化 抽象方法时没有方法体的方法 语法格式 abstract class{ 常量； 变量 构造（）； 抽象方法； // 普通方法； 静态方法（）； } abstract class TrafficToo{ int count ; //没有具体的行为实现 ...
day16_集合：Collections,Queue，Map，Stream流，过滤接口
戴戴的博客
05-30 335
Collections collection | Queue | 实现类PriorityQueue Deque 接口 ：双端队列 | 实现类 ArrayDeque，LinkedList package day23; import java.util.ArrayList; import java.util.Collections; import java.util.List;...
day7__java封装、重载.doc
戴戴的博客
05-16 250
封装 为什么要使用封装？ 隐藏类中的属性和实现细节，对外只提供公共的访问方式 安全性 可以使用流程控制语句对值的限制 只能用我提供的访问方式来访问 this :表示本类对象 作用： 区别成员变量和局部变量同名 调用本类构造器： 注意：位置必须写在构造器的第一行代码处；必须写在 构造器中 set get 访问器：一个属性对应两个访问器； alt+shift+...
day20_java网络编程
戴戴的博客
06-05 244
网络 什么是网络 一组网线连接起来的计算机 作用： 资源共享 传输信息 分布式的计算 综合性的服务 协议 什么是协议：计算机之间通信的规则 常用协议 IP：网际协议，传输信息 TCP：传输控制协议，保证数据的准确传输 HTTP：超文本传输协议 FTP：文件传输协议 SMTP：简单邮件传输协议，发邮件 internet：互联网，是一个通用名词，泛指由...
day3_java分支语句——if、switch、for、 while、do—while
戴戴的博客
05-12 229
----------------------------------------------------                                                控制台输入                     1.导入Scanner类型   请超人; import java.util.Scanner; import java.util.*;2.创建supe...
day_9java继承,object,final基本使用；类之间的继承、组合关系
戴戴的博客
05-18 195
继承 继承的概念 根据已有类派生出新类的技术。还可以有自己的独特属性。 为什么要使用继承？（优势） 代码重用 便于维护（高耦合，代码之间紧密联系） 注意：java类只支持单一继承，不允许多继承：即意味着一个父类可以有多个子类，但是子类只能有多个父类 语法： 编写父类 编写子类：在子类加上 extends 父类名称 使用 一：继承父类：子类继承父类的 “所...
day14_java泛型，枚举
戴戴的博客
05-25 184
泛型： 参数化数据类型 作用于 类，方法，构造器，接口 泛型类： 在声明类的后面加上类型参数 好处 语法 类名&lt;类型参数&gt; 类型参数可以是一个也可以是多个，多个用逗号分隔 用一个大写字母表示，一般用 T-type E—element K—key V—value 原生类型： 类型后没有 指定具体的类型参数，这样的类型 叫 原生类型。 泛...
Java多线程详解：概念、实现与应用
Java中的"day11 java"教程提供了关于线程概念、多线程优势与弊端、以及多线程实现的深入讲解。..."day11 java"的学习资料详细介绍了Java多线程的基础理论、实践应用和注意事项，对理解和使用多线程编程具有重要意义。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值