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

最新推荐文章于 2024-06-20 20:20:21 发布
最新推荐文章于 2024-06-20 20:20:21 发布
阅读量186 收藏
点赞数
分类专栏： 笔记 大数据 文章标签： 多线程 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开发视频教学，阿里创新发布《新高并发宝典》
EDGNB123的博客
05-13 269
前言 很久没有发过文章，今天来说一下应届生找工作的问题吧，就算你是打摆子都要看完~~ 金九银十是社招以及校招的火热时期，但今年很明显没有往年般的火热，面试也是越来越难了。对于应届生来说，如何能够在面试官眼中脱颖而出显得尤为重要。好在，我帮你们找到了一份非常全面的面试资料，针对于应届生以及转行过来的人群都是极具价值的，接下来就一起看看这份笔记。 一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我
java工作流引擎比较，Java开发者必看
m0_57064331的博客
07-10 1305
一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认识这个世界的基础，并用来沟通的手段，如果对架构概念理解不一样，那沟通起来自然不顺畅。 Linux有架构，MySQL有架构，JVM也有架构，使用Java开发、MySQL存储、跑在Linux上的业务系统也有架构，应该关注哪一个？想要清楚以上问题需要梳理几个有关系又相似的概念：系统与子系统、模块与组建、框架与架构: 1
Java多线程学习入门(四)：Java内存模型、Volatile、CAS
qq_43568982的博客
09-13 302
Java内存模型、Volatile、CAS
java编程题库公众号，已获万赞
m0_57286622的博客
05-26 197
什么是分布式锁？在回答这个问题之前，我们先回答一下什么是锁。 普通的锁，即在单机多线程环境下，当多个线程需要访问同一个变量或代码片段时，被访问的变量或代码片段叫做临界区域，我们需要控制线程一个一个的顺序执行，否则会出现并发问题。 如何控制呢？就是设置一个各个线程都能看的见的标志。然后，每个线程想访问临界区域时，都要先查看标志，如果标志没有被占用，则说明目前没有线程在访问临界区域。如果标志被占用了，则说明目前有线程正在访问临界区域，则当前线程需要等待。 这个标志，就是锁。 在单机多线程的java程序中，我们可
升职加薪必看！java编程开发招聘
m0_57699613的博客
07-06 138
一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认识这个世界的基础，并用来沟通的手段，如果对架构概念理解不一样，那沟通起来自然不顺畅。 Linux有架构，MySQL有架构，JVM也有架构，使用Java开发、MySQL存储、跑在Linux上的业务系统也有架构，应该关注哪一个？想要清楚以上问题需要梳理几个有关系又相似的概念：系统与子系统、模块与组建、框架与架构: 1
Java多线程学习入门(二)：Lock接口，线程间通信、线程不安全的容器
qq_43568982的博客
09-11 251
Lock接口，线程间通信、线程不安全的容器
什么才是真正的架构设计
程序猿DD
02-16 368
什么是架构和架构本质在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认...
2021大厂Java面试必问题目
HUAXIAL的博客
06-26 369
前言 提到IT人员，人们的第一印象就是高薪资，包括转行来学Java的人绝大多数都是冲着高薪以及就业广泛来的。 前段时间跟同学聊天，她说她老公在一家互联网公司做Java后台开发，年薪四十万，最近在准备复习，想着明年冲一波阿里p6或者p7。 很多人都听过阿里的p级职位层级，那今天就跟大家“揭秘”一下，想要成为p7岗的Java技术专家你需要掌握哪些技术。 本篇文章我将分成三个内容来讲： ①了解阿里p级职位，大厂岗位薪资（2020） ②阿里p7技术专家水平（Java岗） ③如何让自己一步步贴近p7技术专家 一.
作为一个Java程序员，java工作流引擎比较
m0_57081438的博客
07-09 392
一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认识这个世界的基础，并用来沟通的手段，如果对架构概念理解不一样，那沟通起来自然不顺畅。 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.练习
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 695
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Java爬虫之Jsoup爬Html网页链接
withme977的博客
06-20 266
Java爬虫Jsoup
Day43
最新发布
m0_67496588的博客
06-20 942
JSON，Ajax
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 740
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Spring 事务传播行为之Propagation.NESTED REQUIRES_NEW等探讨
chengmin123456789的博客
06-17 227
当一个事务方法（标记为@Transactional(propagation = Propagation.NESTED))被另一个活动事务调用时，它会创建一个“保存点”（Savepoint）作为新的事务开始点。这意味着，如果这个嵌套事务方法内部发生异常并导致回滚，事务会回滚到这个保存点，而不会影响到外部事务的其他操作。如果一切正常，嵌套事务会在外部事务结束时一起提交。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

十年之伴

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

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

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

打赏作者

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

抵扣说明：

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

余额充值