2021.02.03 第一阶段 21

于 2021-02-03 21:36:33 发布
阅读量120 收藏
点赞数
分类专栏： 第一阶段
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tianxibin/article/details/113617735
版权

1、多线程的线程安全问题
2、多线程的其他内容
3、单例设计模式
4、线程的声明周期
5、线程池
6、单元测试

一、多线程的线程安全问题

（一）问题描述
1、毛某段代码在执行的时候，操作数据还没有操作完毕，CPU就切换到其他的线程上，ITA线程对当前数据做了修改，当CPU再切换回这条线程时，这条线程会接着上一次没有做完的操作继续执行，此时数据就有可能产生问题
2、产生原因：【没有保证操作数据代码执行的完整性、原子性】
3、希望、在代码操作的时候，对数据的操作要么不做，要么做完，在操作数据的过程中，不要让其他线程来操作数据产生干扰
（二）同步代码块
1、同步代码块：使用一种代码格式，达到让某段代码被A线程执行的时候，CPU不会切换到其他线程上去的目的。这样，就可以确保CPU在执行A线程的时候，数据不会被其他线程操作而产生干扰。
2、代码格式：

synchronized（同步锁对象）{
	需要确保操作完整性的代码
}
当前同步锁对象可以是任何一个对象
只要确保会互相干扰的线程上有同一个同步锁对象，就能确保数据安全

3、原理：当CPU想去执行同步代码块的时候，首先要获取同步锁对象，获取到之后，就可以执行同步代码块中的内容了；当CPU执行当前代码块的时候，可以切换到其他线程上去。如果其它线程也需要获取相同的同步锁对象，而正在执行的线程没有释放同步锁对象，则其他线程获取不到同步锁，也就无法执行。必须要等到当前线程将代码执行完毕，结束同步代码块，释放同步锁对象，其它线程才能够再次获取同步锁对象，执行同步代码块的内容。

public class Demo11_SynchronizedBlock {
	public static void main(String[] args) {
		PrintString ps = new PrintString();
		Thread t1 = new Thread() {
			@Override
			public void run() {
					while(true) {
						ps.test1();
				}
			}
		};
		Thread t2 = new Thread() {
			@Override
			public void run() {
				while(true) {
					ps.test2();
				}
			}
		};
		t1.start();
		t2.start();
	}
}
class PrintString {
	Object obj = new Object();
	public void test1() {
		synchronized (obj) {
			System.out.print("耗");
			System.out.print("子");
			System.out.print("尾");
			System.out.println("汁");
		}
	}
	public void test2() {
		synchronized (obj) {
			System.out.print("不");
			System.out.print("讲");
			System.out.print("武");
			System.out.println("德");
		}
	}
}

（三）同步方法
1、如果同步代码块将整个方法体都包围起来了，我们可以用更加简单的方式书写代码：同步方法
2、如果方法体中只有一部分代码需要保证线程同步，则依然使用同步代码块
3、定义格式：

权限修饰符【static】 synchronized 返回值类型 方法名称（参数列表）{
	方法体
}

4、同步方法的同步锁对象：
（1）非静态方法：同步锁对象是当前调用者对象。谁来调用方法，同步锁对象就是谁。
（2）静态方法：同步锁对象是当前类的字节码对象
5、同步锁对象的确定：
（1）如果需要保证线程安全的数据属于对象，就是用【this】作为同步锁对象
（2）如果需要保证线程安全的数据属于类，就用【字节码对象】作为同步锁对象。
字节码对象的获取：【类名.class】
（3）如果数据不属于对象也不属于类，属于方法，那么方法如果是非静态，就用this，如果是静态，就用字节码对象
（三）死锁
1、A线程拥有1号资源，同时B线程拥有2号资源；A线程要执行下去需要2号资源，而B线程要执行下去需要1号资源；每条线程拥有一部分资源的同时，也都需要对方线程的资源，但是每条下称都不会释放各自已经拥有的资源，就会造成死锁，谁也都无法运行下去
2、代码表现：同步代码块嵌套容易形成死锁
（五）线程安全的火车票案例
三个窗口，共售卖100张车票
使用多线程来进行模拟。打印某个窗口买出了1张票，还剩多少张

public class Demo04_Ticket {
	public static void main(String[] args) {
		Window w1 = new Window("窗口1");
		Window w2 = new Window("窗口2");
		Window w3 = new Window("窗口3");
		/*
		* w1.setName("窗口1");
		* w2.setName("窗口2");
		* w3.setName("窗口3");
		*/
		w1.start();
		w2.start();
		w3.start();
	}
}
// 使用多线程模拟窗口
// 多线程中，主要保证数据操作的完整性的代码，要加上同步
class Window extends Thread {
	private static int tickets = 100;
	public Window() {
		super();
	}
	public Window(String name) {
		super(name);
	}
	@Override
	public void run() {
		synchronized (Window.class) {
			while () {
	
				tickets--;
				System.out.println(getName() + "卖出了1张票，还剩" + tickets +"张");
				try {
					Thread.sleep(30);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

public class Demo05_TicketImplWay {
	public static void main(String[] args) {
		//使用线程模拟窗口
		//实现的方式中，自定义类型的对象表示任务
		Ticket t = new Ticket();
		Thread t1 = new Thread(t, "窗口1");
		Thread t2 = new Thread(t, "窗口2");
		Thread t3 = new Thread(t, "窗口3");
		t1.start();
		t2.start();
		t3.start();
	}
}
class Ticket implements Runnable {
	private int tickets = 100;
	@Override
	public void run() {
		while(true) {
			synchronized (this) {
				if (tickets == 0) {
					break;
				}
				tickets--;
				System.out.println(Thread.currentThread().getName() + "卖出了1张票，还剩" + tickets + 
					"张");      		
				try {
				Thread.sleep(30);
				} catch (InterruptedException e) {
				e.printStackTrace();
				}
			}
		}
	}
}

二、多线程的其他内容

（一）其他方法
1、**join()**是当前线程挂起，等待加入的线程完成操作之后，该线程再回复运行
2、**yield()**让步。和sleep很像，短暂的让线程暂停，短的让当前的线程挂起。让别的线程先运行，自己稍作暂停再运行。通常情况下，线程只“让步”于优先级相同或者更高的线程
（二）线程协作
1、需求：让两个线程交替打印1-100的数字。例如A线程就打印1，那么B线程就打印2，随后A打印3，以此类推
2、**wait()让执行它的方法所在的线程进入无限的等待，并且释放同步锁对象。
3、notify() 唤醒一个被wait()**的线程，如果有多条线程，唤醒优先级最高的那个
4、notifyAll() 唤醒所有被wait()的线程
5、注意事项：
（1）**wait()、notify()、notifyAll()**必须在同步代码块或者同步方法中使用
（2）**wait()、notify()、notifyAll()**的调用者必须是同步所对象
（3）**wait()、notify()、notifyAll()**不属于Thread类型，属于Object。因为任何一个类都可以实现Runnable接口，就可能变成任务对象，就可能成为同步锁对象，所以放在Object中，为了任何类型的对象都能调用这些方法
（三）sleep方法和wait()方法的区别
1、相同点：都是让线程进入休眠状态（阻塞态）。
2、不同点：
（1）所属类型不同。sleep方法属于Thread类，wait方法属于Object
（2）调用场景不同。sleep在任何位置都能被调用，wait方法必须在同步代码块或者同步方法中使用
（3）是否释放同步锁对象：如果sleep方法和wait方法都在同步代码块中使用，wait会释放同步锁对象，但是sleep方法不会

三、单例设计模式

（一）概述
1、例：实例、对象。
2、单：一个。
3、设计模式：开发中总结出来的代码的书写、设计套路
4、单例：定义一个类，这个类只能够有一个对象
5、分类：
（1）饿汉式
① 提供对外公开的访问方式，获取已经在类中提前创建好的私有对象
② 将对象提前在类中创建好，并且将对象设置为常量，外界可以直接获取但是无法修改
（2）懒汉式
（二）饿汉式
1、饿汉：对象在类一加载的时候，就去创建好了，就像饥饿的人，一个食物就吃
2、第一种形式

class SingletonHungry {
	//1.构造方法私有化，限制外界创建对象
	private SingletonHungry() {
		super();
	}
	//2.提前在类中创建好对象
	private static SingletonHungry sh = new SingletonHungry();
	//3.提供对外获取实例的方式
	public static SingletonHungry getInstance() {
		return sh;
	}
}

2、第二种形式：

class SingletonHungryEasy {
	//1.构造方法私有化，限制外界创建对象
	private SingletonHungryEasy() {
		super();
	}
	public static final SingletonHungryEasy she = new SingletonHungryEasy();
}

（三）懒汉式
1、懒汉：能拖就拖，能不创建对象就不创建对象

class SingletonLazy {
	//1.构造方法私有化，限制外界创建对象
	private SingletonLazy() {
		super();
	}
	//2.在类中提前创建好对象
	private static SingletonLazy sl;//null
	//3.对外提供公开的访问方式
	public static SingletonLazy getInstance() {
		/*
		* ③ 因为获取锁对象的过程比较慢，为了提升系统效率，
		* 在外层加上一个判断，如果对象已经存在，就不获取锁，不创建对象了
		*/
		if (sl == null) {
			//② 为了保证多线程情况下数据的安全，即只有一个对象，不会重复创建
			synchronized (SingletonLazy.class) {
				//① 判断对象是否存在，如果对象不存在将对象创建好
				if (sl == null) {
					sl = new SingletonLazy();
				}
			}
		}
		return sl;
	}
}

四、线程的生命周期

（一）概述
1、线程是一个动态的概念，有创建到时候，也有运行和变化的时候，也有消亡的时候，这个从生到死的过程，就是线程的生命周期。在线程的生命周期中，有各种各样的状态，其中一些状态可以相互转换。
2、别名：线程的状态图，线程的状态周期
3、状态划分：
（1）新建态：将线程对象创建好，尚未start()
（2）就绪态：已经创建好并且start()的线程，只是CPU没有来临
（3）运行态：正在运行着的线程
（4）阻塞态：线程正在等待资源；线程sleep、wait等；这种状态下，就算CPU来临也无法运行
（5）死亡态：线程运行完毕、出现了异常、线程被破坏等
（二）状态转换图
在这里插入图片描述（三）Java中关于线程状态的描述
1、我们上述的线程状态仅仅是定性分析，停留在理论层面，具体代码在运行过程，线程到底是什么状态，Java官方给出了更加细致的描述，可以通过一些方法获取到这些线程状态。Java官方给出的这些状态，可能和我们定性分析的有所差别
2、获取线程状态的方法：getState()
3、该方法的返回值类型：Thread.State
说明：由于线程的状态是有限的，所以使用一个类型的对象，来描述不同的线程状态。此处对象的个数也是有限的。并且这些对象提前在类中已经创建好了，我们获取线程状态的时候，底层会直接将已经创建好的对象返回回来，具有有限个已经创建好的对象的类型，就是枚举。每个对象，叫做枚举项。
4、官方给定的线程状态：
（1）NEW ：新建态
（2）RUNNABLE：运行态
（3）BLOCKED：阻塞态（等待锁对象）
（4）WAITING：阻塞态（线程被wait()）
（5）TIMED_WAITING：阻塞态（被sleep(int millis)）
（6）TERMINATED：死亡态

五、线程池

（一）概述
1、没有线程池：
（1）当我们创建一条线程之后，线程执行的任务破坏力比较大，可能任务没有执行完，线程就被破坏了，此时如果想要继续执行这个任务，我们无法操作
（2）当线程正常执行完任务之后，会进入死亡态，变为系统垃圾，这个线程就无法继续利用了，会被系统回收
（3）尤其：线程要执行的任务都是很小的任务，我们创建好线程之后，仅仅是简单的执行，线程就进入了死亡态变成了系统垃圾，这样一来，资源消耗比较大，线程的利用率也不高
2、有线程池：
（1）当我们将任务交给线程池，线程池会自动安排线程执行任务，如果任务破坏力较大，线程被破坏
了，线程池会安排另一条线程继续执行没有完成的任务
（2）线程池中的线程执行完任务之后，不会进入死亡态，而是被线程池回收，继续在线程池中活跃，
等待下次继续执行任务
（二）线程池的使用
1、我们只需要创建线程池，指定线程池中线程的数量，当线程池创建完毕之后，就会带有指定数量线程。之后我们直接将任务提交到线程池，线程池会自动安排线程执行任务。
2、步骤：
（1）Executors工具类，是用于生成线程池的工具类，我们可以调用类中的方法，指定生成的线程池中有多少个线程
（2）ExecutorService Executors.newFixedThreadPool(int nThreads) 创建一个线程池，线程池中线程数量由参数指定
（3）ExecutorService Executors.newSingleThreadExecutor() 创建一个具有单个线程的线程池
3、线程池的使用：
（1）创建任务对象
（2）将任务提交到线程池中
（3）常用方法
submit(Runnable task) 向线程池中提交任务。如果任务数量大于线程数量，会安排线程先执行一部分任务，剩余的排队等待。当前面的任务被哪个线程执行完，线程池会立马安排这个线程执行排队的任务
shutdown() 关闭线程池。执行已经提交的任务，不接受新任务
shutdownNow() 关闭线程池，不执行排队的任务，试图结束正在执行的任务

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo11_ThreadPool {
	public static void main(String[] args) {
	//1.获取线程池
	ExecutorService es = Executors.newFixedThreadPool(2);
	//2.准备任务对象
	Runnable task1 = new Runnable() {
		public void run() {
			for (int i = 1; i <= 1000; i++) {
				System.out.println(Thread.currentThread().getName() + "------" + i);
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	};
	Runnable task2 = new Runnable() {
			public void run() {
			for (int i = 2000; i <= 2999; i++) {
				System.out.println(Thread.currentThread().getName() + "------" + i);
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	};
	Runnable task3 = new Runnable() {
		public void run() {
			for (int i = 9000; i <= 9999; i++) {
				System.out.println(Thread.currentThread().getName() + "------" + i);
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	};
	//3.将任务提交到线程池中
	es.submit(task1);
	es.submit(task2);
	//es.shutdown();
	es.submit(task3);
	es.shutdownNow();
	}
}

六、单元测试

（一）概述
1、测试的重要性：好的软件不是开发出来的，是测试出来的
2、软件测试的分类：
（1）黑盒测试：测试工程师
将软件看作是一个打不开的黑盒子，完全不需要考虑盒子内部的结构和逻辑，仅仅是对功能的完整性等的一个测试
（2）白盒测试：开发工程师
将软件看成是一个白盒子，盒子里面的内容都可以查看到。进行测试的时候，跟多是针对代码的逻
辑、效率等的测试
3、单元测试，就是白盒测试
4、测试现行的思想：如果不知道怎么测试，就不要去写代码
5、常用的单元测试：JUnit4.x
（1）JUnit3.x 主要是对JDK5之前的版本测试
（2）JUnit4.x 常用，用于JDK5之后的版本，对一些新功能的支持较好
（3）JUnit5.x
（二）JUnit单元测试使用
1、方式一：
（1）搭建环境
（2）创建单元测试类型：
① 类名一般是被测试类名+Test例如：被测试类是ArrayTools，测试类名称是ArrayToolsTest
② 测试类必须是public修饰的
③ 要有一个空参的public构造
（3）编写单元测试方法：
① 权限是public
② 返回值必须是void
③ 没有参数列表
④ 测试方法名，必须是test+被测试方法名。例如：方法名printArr，测试方法名：testPrintArr

@Test
public void test() {
}

（4）运行：双击选中方法名称 -> Run as -> JUnit Test
（5）测试结果：如果出现绿条，就证明没有问题；红条就是有错误
2、方式二：直接在测试类中书写注解test，之后鼠标点击导入资源即可，其余和方式一相同
3、方式三：在要测试的【.java】文件上，右键 -> new -> JUnit test case -> next -> 选择需要生成对应测试方法的方法 -> finish，自动生成测试类

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值