稳稳当当学java之并发编程(20）

最新推荐文章于 2024-06-14 15:02:13 发布
最新推荐文章于 2024-06-14 15:02:13 发布
阅读量185 收藏
点赞数
分类专栏： 笔记 大数据 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42405054/article/details/108392587
版权

第二十二章 并发编程

1.作业回顾

以指定的编码读取文件内容，并将读到的内容以指定的编码写文件，两种编码都配置到properties文件中。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.util.Properties;

public class Day2201 {
	public static void main(String[] args) {
		String readCharset = null;
		String writeCharset = null;
		String readFilePath = null;
		String writeFilePath = null;
		
		InputStream is = Day2201.class.getResourceAsStream("/file.properties");
		Properties props = new Properties();
		
		try {
			props.load(is);
			readCharset = props.getProperty("readFilePath");
			writeCharset = props.getProperty("writeCharset");
			readFilePath = props.getProperty("readFilePath");
			writeFilePath = props.getProperty("writeFilePath");
		
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		InputStreamReader isr = null;
		OutputStreamWriter osw = null;
		
		try {
			isr = new InputStreamReader(new FileInputStream(readFilePath), readCharset);
			osw = new OutputStreamWriter(new FileOutputStream(writeFilePath), writeCharset);
			
			char[] chars = new char[256];
			int len = 0;
			
			while(-1 != (len = isr.read(chars))){
				osw.write(chars, 0, len);
			}	
			
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				isr.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				osw.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				osw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}	
	}
}

2.进程和线程

​ 在并发编程中，有两个基本的执行单元，进程和线程。

​ 计算机运行时拥有很多活动的进程和线程，即使是单核系统也是如此。

​ 进程可以理解为一个正在运行的软件，进程在运行时有独立的资源和内存空间。进程与进程之间不共享数据。进程的创建开销很大，因为要分配独立的资源和内存空间。

​ 线程，例如音乐播放器在播放声音的同时可以滚动歌词，每个功能都由单独的一个线程来完成。 一个进程由很多线程组成，线程与线程之间共享进程的资源和内存空间。线程的创建开销很小，因为不需要分配独立的资源和内存空间。

​ 计算机在运行时有很多线程，但是同一时刻只能有一个线程能运行。为了保证每个线程都能得到执行，操作系统将cpu的时间分为一个个细小的时间片，并给线程分配执行权。当一个线程获得cpu的执行权后，它可以在时间片内运行，当时间片过后，线程被剥夺执行权，操作系统开始进行下一轮执行权的分配。因为时间片很短，在一秒内每个线程都将得到多次执行机会，因此在用户的角度来看，感觉线程是并行执行的。

​ 执行java程序需要使用java命令，java命令会运行java.exe程序，因此会创建一个进程。当java进程创建后，会创建一个线程来执行main方法的代码，这个线程叫做主线程。我们之前运行的java程序都是单线程的。

3.创建线程

在java中创建线程有两种方式：继承Thread类，实现Runnable接口。

3.1 继承Thread类来创建线程

class Mythread1 extends Thread{
	//重写run方法
	//当线程得到执行权，就会执行run方法中的代码
	//当run方法中的代码执行完毕后，线程就死掉了
	//线程可能run方法没有执行完毕，时间片就结束了
	//线程会记录它执行的哪个代码了，当再次得到时间片，它会接着往下执行
	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
//			System.out.println(this.getName() + ":" + (i + 1));
			System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
		}
	}
}

public class Day2202 {
	public static void main(String[] args) {
		Thread t1 = new Mythread1();//创建一个线程对象t1,并不是真正的在创建线程
		Thread t2 = new Mythread1();//创建一个线程对象t2,并不是真正的在创建线程
		
		//start方法是启动线程，至于这个线程什么时候得到执行权，要看操作系统的调度
		t1.start();//启动线程t1
		t2.start();//启动线程t2
		
		for (int i = 0; i < 1000; i++) {
			//主线程
			//得到当前线程，执行此代码的线程对象
			Thread mainThread = Thread.currentThread();
			//getName方法会返回线程的名字
			System.out.println(mainThread.getName() + ":" + (i + 1));
		}	
	}
}

3.2 实现Runnable接口来创建线程

class MyThread2 implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			//输出当前线程的名字
			System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
		}	
	}	
}

public class Day2203 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyThread2());
		
		t1.start();
		
		Thread t2 = new Thread(new MyThread2());
		
		t2.start();
	}
}

4.线程类的方法

4.1 sleep方法

Thread.sleep(long millis)导致当前线程暂停执行指定的时间段。

public class Day2204 {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + (i + 1));
			
			try {
				//让当前线程睡眠1000毫秒
				//让出执行权，进行睡眠，睡眠结束后再参与cpu执行权的争夺
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

4.2 join方法

t1.join方法将导致当前线程等待t1执行完毕。

public class Day2205 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 200; i++) {
					//输出当前线程的名字
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
				}	
			}
		});
		//修改名称为t1
		t1.setName("t1");
		
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					//输出当前线程的名字
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
				}
			}
		});
		//修改名称为t2
		t2.setName("t2");
				
		Thread t3 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					//输出当前线程的名字
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
				}
			}
		});
		//修改名称为t3
		t3.setName("t3");
		
		//t1和t2和主线程一起争夺时间片
		t1.start();
		t2.start();
		
		try {
			//让当前线程（主线程）暂停执行，等待t2执行结束主线程在恢复执行
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}		
		
		System.out.println("主线程恢复执行");
		t3.start();
	}
}

4.3 stop方法

t1.stop会导致线程t1立即终止执行。

public class Day2206 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
				}
				
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}	
			}
		});
		
		t1.start();
		
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		//终止t1的执行
		t1.stop();
		//t1至少需要1000毫秒才可以执行完毕
		//主线程睡100毫秒后t1还没执行完毕
	}
}

4.4 interrupt方法

t1.interrupt会将设置t1线程为中断状态，但不会导致t1线程立即终止执行。 被中断的线程可以选择继续执行，也可以选择停止执行。

public class Day2207 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 1000; i++) {
					//检查当前线程是否被打断
					//isInterrupted方法返回中断状态
					if (Thread.currentThread().isInterrupted()) {
						System.out.println("线程被打断了");
						break;					
					}else {
						System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
					}					
				}				
			}
		});
		
		t1.start();
		
		try {
			//让主线程先睡10毫秒
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		//打断线程t1，设置t1的中断状态为true
		t1.interrupt();
	}
}

4.5 守护线程

java中的线程分为两种：守护线程和非守护线程。

守护线程是一种特殊的线程，当java虚拟机中所有的非守护线程都执行完毕后，守护线程就会终止执行。java中的垃圾回收器GC就是守护线程的典型例子。

平常使用的都是非守护线程。

public class Day2208 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1));
					
				}
			}
		}, "t1");
		
		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				while(true) {
					System.out.println("守护线程在运行");
				}
			}
		}, "t2");
		
		//设置t2为守护线程
		t2.setDaemon(true);
		
		t1.start();//非守护线程执行完
		t2.start();//守护线程就会终止执行
	}
}

5.多线程并发问题

5.1原因

线程是并行执行的，当两个线程同时修改同一个数据，就会产生线程并发问题。

public class Account {
	private int money = 0;
	
	public void increase() {
		money = money + 1;
	}
	
	public void decrease() {
		money = money - 1;
	}

	@Override
	public String toString() {
		return "Account [money=" + money + "]";
	}
}

public class IncreaseThread extends Thread{
		private Account account;

		public IncreaseThread(Account account) {
			super();
			this.account = account;
		}
		
		public void run() {
			for (int i = 0; i < 10000; i++) {
				account.increase();
			}
		}
}

public class DecreaseThread extends Thread{
		private Account account;

		public DecreaseThread(Account account) {
			super();
			this.account = account;
		}
		
		public void run() {
			for (int i = 0; i < 10000; i++) {
				account.decrease();
			}
		}
}

public class Day2209 {
	public static void main(String[] args) {
		Account account = new Account();
		
		Thread t1 = new IncreaseThread(account);
		
		Thread t2 = new DecreaseThread(account);
		
		t1.start();
		
		t2.start();
		
		//主线程等待t1和t2执行结束
		try {
			t1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		try {
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println(account);//有正有负
	}
}

在这里插入图片描述

5.2 synchronized同步代码块

使用同步代码块，来保证增加1和减少1的操作都是原子的。

public class IncreaseThread extends Thread{
		private Account account;

		public IncreaseThread(Account account) {
			super();
			this.account = account;
		}
		
		public void run() {
			for (int i = 0; i < 10000; i++) {
				
				//synchronized是同步代码块
				//要执行同步代码块，必须先获取account对象的锁
				//每个对象都有一把锁
				//同步锁同一时刻只能被一个线程获取
				//没有获得锁的线程就会等待别的线程释放锁
				//当线程在执行同步代码块时，时间片结束，线程会暂停执行，但是不会释放锁
				//如果一个线程期望得到锁但是没有得到，那么它会放弃时间片
				synchronized (account) {
					account.increase();
				}
				
			}
		}
}

public class DecreaseThread extends Thread{
		private Account account;

		public DecreaseThread(Account account) {
			super();
			this.account = account;
		}
		
		public void run() {
			for (int i = 0; i < 10000; i++) {
				
				synchronized (account) {
					account.decrease();
				}
				
			}
		}
}

6.练习

1，继承Thread类创建一个线程t1，实现Runnable接口创建一个线程t2。t1中使用for循环输出1000次自己的名字，每次输出后睡眠10毫秒，t2中使用for循环输出1000次自己的名字，每次输出后睡眠20毫秒。让主线程等待t1和t2都执行结束，主线程才恢复执行。

十年之伴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java多线程学习入门(四)：Java内存模型、Volatile、CAS
qq_43568982的博客
09-13 298
Java内存模型、Volatile、CAS
java编程题库公众号，已获万赞
m0_57286622的博客
05-26 191
什么是分布式锁？在回答这个问题之前，我们先回答一下什么是锁。 普通的锁，即在单机多线程环境下，当多个线程需要访问同一个变量或代码片段时，被访问的变量或代码片段叫做临界区域，我们需要控制线程一个一个的顺序执行，否则会出现并发问题。 如何控制呢？就是设置一个各个线程都能看的见的标志。然后，每个线程想访问临界区域时，都要先查看标志，如果标志没有被占用，则说明目前没有线程在访问临界区域。如果标志被占用了，则说明目前有线程正在访问临界区域，则当前线程需要等待。 这个标志，就是锁。 在单机多线程的java程序中，我们可
升职加薪必看！java编程开发招聘
m0_57699613的博客
07-06 137
一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认识这个世界的基础，并用来沟通的手段，如果对架构概念理解不一样，那沟通起来自然不顺畅。 Linux有架构，MySQL有架构，JVM也有架构，使用Java开发、MySQL存储、跑在Linux上的业务系统也有架构，应该关注哪一个？想要清楚以上问题需要梳理几个有关系又相似的概念：系统与子系统、模块与组建、框架与架构: 1
Java多线程学习入门(二)：Lock接口，线程间通信、线程不安全的容器
qq_43568982的博客
09-11 250
Lock接口，线程间通信、线程不安全的容器
java开发视频教学，阿里创新发布《新高并发宝典》
EDGNB123的博客
05-13 265
前言 很久没有发过文章，今天来说一下应届生找工作的问题吧，就算你是打摆子都要看完~~ 金九银十是社招以及校招的火热时期，但今年很明显没有往年般的火热，面试也是越来越难了。对于应届生来说，如何能够在面试官眼中脱颖而出显得尤为重要。好在，我帮你们找到了一份非常全面的面试资料，针对于应届生以及转行过来的人群都是极具价值的，接下来就一起看看这份笔记。 一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我
java工作流引擎比较，Java开发者必看
m0_57064331的博客
07-10 1300
一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认识这个世界的基础，并用来沟通的手段，如果对架构概念理解不一样，那沟通起来自然不顺畅。 Linux有架构，MySQL有架构，JVM也有架构，使用Java开发、MySQL存储、跑在Linux上的业务系统也有架构，应该关注哪一个？想要清楚以上问题需要梳理几个有关系又相似的概念：系统与子系统、模块与组建、框架与架构: 1
什么才是真正的架构设计
程序猿DD
02-16 366
什么是架构和架构本质在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认...
2021大厂Java面试必问题目
HUAXIAL的博客
06-26 363
前言 提到IT人员，人们的第一印象就是高薪资，包括转行来学Java的人绝大多数都是冲着高薪以及就业广泛来的。 前段时间跟同学聊天，她说她老公在一家互联网公司做Java后台开发，年薪四十万，最近在准备复习，想着明年冲一波阿里p6或者p7。 很多人都听过阿里的p级职位层级，那今天就跟大家“揭秘”一下，想要成为p7岗的Java技术专家你需要掌握哪些技术。 本篇文章我将分成三个内容来讲： ①了解阿里p级职位，大厂岗位薪资（2020） ②阿里p7技术专家水平（Java岗） ③如何让自己一步步贴近p7技术专家 一.
作为一个Java程序员，java工作流引擎比较
m0_57081438的博客
07-09 391
一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认识这个世界的基础，并用来沟通的手段，如果对架构概念理解不一样，那沟通起来自然不顺畅。 Linux有架构，MySQL有架构，JVM也有架构，使用Java开发、MySQL存储、跑在Linux上的业务系统也有架构，应该关注哪一个？想要清楚以上问题需要梳理几个有关系又相似的概念：系统与子系统、模块与组建、框架与架构: 1
稳稳当当学java之面向对象编程(8)
06-02
本人的笔记，关于java基础中面向对象编程的内容 包括 1.作业回顾 2.类和对象 3.实例方法 4.成员变量 5.练习
稳稳当当学java之继承(10)
06-05
本人的笔记，关于java基础中继承的内容 包括 1.作业回顾 2.成员变量的初始值 3.对象初始化 4.继承 5.子类对象的实例化过程 6.继承的规则一 7.练习
稳稳当当学java之数组(7)
06-01
本人的笔记，关于Java基础中数组的内容 包括 1.作业回顾 2.数组的概念 3.创建，初始化，和访问数组 4.遍历数组 5.基本数据类型和引用数据类型的区别 6.使用Arrays类 7练习
稳稳当当学java之方法(6).md
05-29
本人的笔记，关于Java基础中方法的内容。 包括 1.作业回顾 2.方法的定义 3.向方法传递参数 4.方法返回值 5.方法重载 6.变量的作用域 7.使用类常量和类方法 8.练习
稳稳当当学java之循环(5).md
05-29
本人的笔记，关于Java基础中循环的内容 包括 1.作业回顾 2.while 循环 3.do while 循环 4.for 循环 5.break语句 6.continue 语句 7.练习
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 306
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 527
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 598
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 396
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 824
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十年之伴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值