Day19-异常和线程

---

异常

异常机制

1. 异常概念

异常是程序在运行期发生的不正常的事件，它会打断指令的正常执行流程。

设计良好的程序应该在异常发生时提供处理这些不正常事件的方法，使程序不会因为异常的发生而阻断或产生不可预见的结果。
Java语言使用异常处理机制为程序提供了异常处理的能力

2. 异常分类

Java程序运行过程中所发生的异常事件从严重性可分为两类：
1、 错误(Error)：JVM系统内部错误或资源耗尽等严重情况－属于JVM需要负担的责任这一类异常事件无法恢复或不可能捕获，将导致应用程序中断。

package com.dream.test01;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 1、错误(Error)：
		 * JVM系统内部错误或资源耗尽等严重情况－属于JVM需要负担的责任这一类异常事件无法恢复或不可能捕获，
		 * 将导致应用程序中断。
		 * 
		 * StackOverflowError - 栈内存溢出的错误
		 * 出现原因：调用方法就会在栈内存中开辟空间，死循环的调用方法，栈内存就装满了
		 */
		
		method();
		
	}
	
	public static void method(){
		method();
	}
}

package com.dream.test01;

import java.util.ArrayList;

public class Test02 {
	
	public static void main(String[] args) {
		/**
		 * 1、错误(Error)：
		 * JVM系统内部错误或资源耗尽等严重情况－属于JVM需要负担的责任这一类异常事件无法恢复或不可能捕获，
		 * 将导致应用程序中断。
		 * 
		 * OutOfMemoryError - 堆内存溢出的错误
		 */
		
		ArrayList<String[]> list = new ArrayList<>();
		
		while(true){
			String[] ss = new String[1000];
			list.add(ss);
		}
		
	}
	
}

2、 异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。

运行时异常（RunntimeException）非受检性异常：那些程序员在编写程序的时z免的异常（逻辑异常），数组越界异常，类型转换异常，空指针异常
非运行时异常：程序员避免不了，由外界因素导致的
注册：年龄 s
做一个程序可以去读取指定路径的文件内容
路径：用户来给

Exception分类：
(数组越界，空指针，类型转换错误)
1、非受检(unchecked)异常(运行时异常 RuntimeException)：编译器不要求强制处置的异常。一般是指编程时的逻辑错误。是程序员应该积极避免其出现的异常java.lang.RuntimeException及它的子类都是非受检异常：
错误的类型转换：java.lang.ClassCastException

package com.dream.test01;


public class Test05 {
	
	public static void main(String[] args) {
		/**
		 * 2、异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
		 * 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
		 * 
		 * 注意：所有的异常都是程序运行过程中出现的异常
		 * 
		 * RuntimeException - 运行时异常：编译器不要求强制处置的异常，非受检性异常：那些程序员在编写程序的时应避免的异常（逻辑异常）
		 * 
		 * ClassCastException - 类型转换异常
		 * 应该使用instanceof判断
		 */
		
		Object obj = new String();
		Integer integer = (Integer)obj;
		System.out.println(integer);
	}
	
}

数组下标越界：java.lang.ArrayIndexOutOfBoundsException

package com.dream.test01;


public class Test04 {
	
	public static void main(String[] args) {
		/**
		 * 2、异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
		 * 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
		 * 
		 * 注意：所有的异常都是程序运行过程中出现的异常
		 * 
		 * RuntimeException - 运行时异常：非受检性异常：编译器不要求强制处置的异常，那些程序员在编写程序的时应避免的异常（逻辑异常）
		 * 
		 * ArrayIndexOutOfBoundsException - 数组下标越界异常
		 */
		
		int[] is = new int[10];
		
		System.out.println(is[100]);
	}
	
}

空指针访问：java.lang.NullPointerException

package com.dream.test01;


public class Test06 {
	
	public static void main(String[] args) {
		/**
		 * 2、异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
		 * 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
		 * 
		 * 注意：所有的异常都是程序运行过程中出现的异常
		 * 
		 * RuntimeException - 运行时异常：非受检性异常：编译器不要求强制处置的异常，那些程序员在编写程序的时应避免的异常（逻辑异常）
		 * 
		 * NullPointerException - 空指针异常
		 */
	
		method(null);
	}
	
	public static void method(String str){
		System.out.println(str.length());
	}
	
}

类未找到异常:ClassNotFoundException

package com.dream.test01;

import java.util.Scanner;

public class Test07 {
	
	public static void main(String[] args) throws ClassNotFoundException {
		/**
		 * 2、异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
		 * 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
		 * 
		 * 注意：所有的异常都是程序运行过程中出现的异常
		 * 
		 * 一般性异常 ：受检(checked)异常，编译器要求必须处置的异常。指的是程序在运行时由于外界因素造成的一般性异常。
		 * 
		 * ClassNotFoundException - 类未找到异常
		 */
	
		Scanner scan = new Scanner(System.in);
		
		String classPath = scan.next();
	
		//通过字符串找到该类的字节码文件
		Class<?> c = Class.forName(classPath);
	
		System.out.println(c);
		
		scan.close();
	}
	
}

算术异常(除0溢出)：java.lang.ArithmeticException

package com.dream.test01;


public class Test03 {
	
	public static void main(String[] args) {
		/**
		 * 2、异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。
		 * 这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
		 * 
		 * 注意：所有的异常都是程序运行过程中出现的异常
		 * 
		 * RuntimeException - 运行时异常：非受检性异常：编译器不要求强制处置的异常，那些程序员在编写程序的时应避免的异常（逻辑异常）
		 * 
		 * ArithmeticException - 数学计算类异常
		 */
		
		System.out.println(10/0);
	}
	
}

2、受检(checked)异常 — 一般性异常：编译器要求必须处置的异常。指的是程序在运行时由于外界因素造成的一般性异常。
没有找到指定名称的类：java.lang.ClassNotFoundException
访问不存在的文件：java.io.FileNotFoundException
操作文件时发生的异常：java.io.IOException
操作数据库时发生的异常：java.sql.SQLException

3. 异常处理机制

1、 Java程序在执行过程中如果出现异常，会自动生成一个异常类对象，该异常对象将被自动提交给JVM，这个过程称为抛出(throw)异常。
2、 当JVM接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获(catch)异常和处理异常。
3、 如果JVM找不到可以捕获异常的代码，则运行时系统将终止，相应的Java程序也将退出。
3.1. 异常处理方式1-----捕获异常

try{
	......	//可能产生异常的代码 
}catch( ExceptionName1 e ){
	......	//异常的处理代码 
}catch( ExceptionName2 e ){
    ...... 	 //异常的处理代码 
} finally{
    ......	 //无论如何都会执行的语句 
}

说明：

1. try 代码段包含的是可能产生异常的代码
2. try 代码段后跟一个或多个catch代码段。(或跟一个finally代码段)
3. JDK新特性，一个catch代码可以可以声明多个能处理的特定异常的类型，多个类型之间用”|”隔开

例如：catch( ExceptionName1  | ExceptionName2	 e){
	......	//异常的处理代码 
}

4. 当异常发生时，程序会中止当前的流程去执行相应的catch代码段。
5. 写catch代码时，先捕获的异常的范围不能大于后捕获的异常的范围。大的异常要写在后面
6. finally段的代码无论是否发生异常都执行。
   3.2. 异常处理方式2-----throws抛出异常类型，一般与下面的结合
   在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用出进行处理。
   1，本身的程序处理不了了，往上一层抛，由上一层去处理
   2，定义一个方法的时候，通过这种方式来告知调用方，我这个方法有可能会发生异常的。
   public void test() throws IOException{
   }
   throws使用格式：

public 返回值类型 方法名(参数列表) throws 异常类{
}

package com.dream.test02;

public class Test04 {

	public static void main(String[] args) {
		/**
		 * thorws 抛出异常
		 * 
		 *
		 * 方法() throws 异常类型{}
		 * 调用该方法的方法需要处理这个方法中的异常
		 */

		try {
			method01();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

	}

	public static void method01() throws ClassNotFoundException{
		method02();
	}

	public static void method02() throws ClassNotFoundException{
		method03();
	}

	public static void method03() throws ClassNotFoundException{
		Class<?> c = Class.forName("java.lang.Math1");
		System.out.println(c);
	}
}

注意：此时抛出的是异常类型，并且抛出的异常类型是紧跟在方法名之后。
3.3. 异常处理方式3-----throw抛出单个具体异常对象
异常不仅仅虚拟机可以抛，我们自己也可以抛。我们可以在代码中使用throw关键字(注意不带s)来抛出某个具体的异常对象。很多情况下我们会手动抛出运行时异常。
例如：
throw new RuntimeException(“程序出现了异常”);

package com.dream.test02;

import java.util.Scanner;

public class Test05 {
	
	public static void main(String[] args) {
		/**
		 * throw 抛出异常
		 * 
		 * 应用场景：手动抛出异常 + 自定义异常
		 */
		
		Scanner scan = new Scanner(System.in);
		
		int a = scan.nextInt();
		int b = scan.nextInt();
		
		try {
			if(b == 0){
				throw new MyException();//手动抛出异常
			}
		} catch (MyException e) {
			//处理异常
			b = 1;
		}
		
		System.out.println(a/b);
		
		scan.close();
		
	}

}

结合自定义异常来说明

4. 自定义异常类

4.1. 创建自定义异常
创建自定义异常，需要继承Exception 或其子类。

public class MyException extends Exception {   
      @Override
	public String toString() {
		// TODO Auto-generated method stub
		return "我们自己的异常类";
	}
}

4.2. 使用自定义异常
解决业务需求上的问题

线程

一、什么是进程

a) 进程是系统进行资源分配和调用的独立单元，每一个进程都有它的”独立”内存空间和系统资源。

二、单进程操作系统和多进程操作系统的区别

b) 多进程操作系统是指在同一个时段内可以执行多个任务
c) 边听音乐边敲代码，CPU切换非常快
d) Windows操作系统-多进程操作系统
e) Dos操作系统-单进程的操作系统
f) Linux操作系统-多用户多进程的操作系统
多用户：同时运行多个用户
g) 单用户 vs 多用户

三、现在的多核CPU是否可以让系统在同一个时刻可以执行多个任务吗？

理论是支持同一时刻执行多个任务

四、什么是线程，理解线程和进程的关系

h) 线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源
一个进程 – 多线程：各个线程都有不同的分工

进程：进程之间的内存空间和系统资源是独立的
线程：线程之间是共享内存空间和系统资源的
进程里：可以有一条或一条以上的线程

进程里只有一条线程的情况下，这条线程就叫做主线程
进程里有多条线程的情况下，只有一条线程叫做主线程

Ps：线程是在进程里的，他们是包裹关系

五、我们应用的软件有哪些是多线程的应用？

自己找个软件，分析一下里面有哪些多线程
QQ、微信：多线程
线程在Android：异步操作（网络下载）

六、Java中，如何来编写多线程的应用程序？有哪些方法？

a) 创建一个自己的线程类，继承Thread，重写run方法
MyThread类

package com.dream.test01;

/**
 * 线程类：
 * 	1.创建MyThread类
 * 	2.继承Thread
 * 	3.重写run方法
 */
public class MyThread extends Thread{

	@Override
	public void run() {
		System.out.println("子线程抢到资源了");
	}
}

测试类

package com.dream.test01;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 使用线程类的方式 操作线程
		 */
		
		//创建子线程的对象
		MyThread t = new MyThread();
		//启动子线程
		t.start();//子线程抢到CPU资源后，才会调用run方法
	}
}

b) 创建一个自己的任务类，实现Runnable接口，重写run方法
Task类

package com.dream.test02;

/**
 * 任务类
 * 	1.创建Task类
 * 	2.实现Runnable接口
 *	3.重写run方法
 */
public class Task implements Runnable{

	@Override
	public void run() {
		System.out.println("执行了任务");
	}

}

测试类

package com.dream.test02;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 使用任务类的方式 操作线程
		 */
		
		//1.创建子线程
		Thread t = new Thread(new Task());
		//2.启动子线程
		t.start();
		
	}
}

c) 创建带有返回值的线程
下章学习

七、Main方法，一个程序执行的主线程，要编写多线程程序就可以在该主线程的基础上来开启新的线程

i) 如何正确启动一个新的线程？以继承Thread的方式为例
j) 另外一种实现多线程的方式，注意，这种方式与上述方式的区别
k)
l) 练习：
m) 编写一个多线程的应用程序，主线程打印1-100之间的数字，子线程打印200-300之间的数字，观察其输出的结果，体会多线程互相争抢资源的场景
MyThread类

package com.dream.test03;

public class MyThread extends Thread{

	@Override
	public void run() {
		for (int i = 200; i <= 300; i++) {
			System.out.println("子线程：" + i);
		}
	}
}

测试类

package com.dream.test03;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 感受多线程之间争抢资源的场景
		 * 
		 * 需求：编写一个多线程的应用程序，
		 * 主线程打印1-100之间的数字，
		 * 子线程打印200-300之间的数字，观察其输出的结果，体会多线程互相争抢资源的场景
		 */
		
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <= 100; i++) {
			System.out.println("主线程：" + i);
		}
		
	}

}

八、小结

n) 继承Thread，重写run方法，创建线程对象，调用start方法（并非马上调用run方法）
o) 实现Runnable接口，重写run方法，创建Runnable对象，通过new Thread(task).start()
p) 主线路从上往下，多线程多条执行路线（随机）
q) 经典面试题：请问当我们编写一个单纯的main方法时，此时该程序是否为单线程的？为什么？System.out.println();

垃圾回收器，多线程的模式

九、线程的优先级

r) 练习：在主线程中创建两个以上的子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。
thread.setPriority(Thread.MAX_PRIORITY);
thread.setPriority(Thread.MIN_PRIORITY);
thread.setPriority(Thread.NORM_PRIORITY);
A类

package com.dream.test04;

public class A extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}

B类

package com.dream.test04;

public class B extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("B：" + i);
		}
	}
}

C类

package com.dream.test04;

public class C extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("C：" + i);
		}
	}
}

测试类

package com.dream.test04;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 线程的优先级别
		 * 
		 * 需求：在主线程中创3个子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。
		 */
		
		A a = new A();
		B b = new B();
		C c = new C();
		
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
	}
}

十、给线程自定义名称

1.自己写getThreadName/setThreadName
2.调用父类的一个参数的构造方法和getName
3.Thread.currentThread().getName()
MyThread类

package com.dream.test05;

public class MyThread extends Thread{
	
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			
			//Thread.currentThread()获取到当前的线程对象
			System.out.println(Thread.currentThread().getName() + "：" + i);
		}
	}
}

测试类

package com.dream.test05;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 给线程取名字
		 * 
		 */
		
		MyThread a = new MyThread("A");
		MyThread b = new MyThread("B");
		MyThread c = new MyThread("C");
		
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
	}
}

十一、让线程休眠 sleep

s) 练习：编写一个抽取学员回答问题的程序，要求倒数三秒后输出被抽中的学员姓名
i. 采用数组存储6个学员姓名 String[]
ii. 生成0-5之间的随机数，确定被抽中的学员 start,end
iii. 在屏幕每隔一秒，依次输出3，2，1，然后输出学员姓名

package com.dream.test06;

import java.util.Random;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 让线程休眠
		 * 
		 * 需求：编写一个抽取学员回答问题的程序，要求倒数三秒后输出被抽中的学员姓名
		 */
		
		String[] names = {"杨晨","陈希","邓静涵","王永琪"};
		
		Random random = new Random();
		int index = random.nextInt(names.length);
		
		for (int i = 3; i >= 1; i--) {
			System.out.println(i);
			try {
				Thread.sleep(1000);//休眠1000毫秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		System.out.println(names[index]);
	}
}

十二、线程的礼让 yield

t) 正确理解线程的礼让，暂停当前正在执行的线程对象，并执行其他线程。
u) 练习：创建两个线程A,B，分别各打印100次，从1开始每次增加1，其中B一个线程，每打印一次，就yield一次，观察实验结果
v) Yield编写的位置
w) Thread.yield();
A类

package com.dream.test07;

public class A extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}

B类

package com.dream.test07;

public class B extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("B：" + i);
			Thread.yield();//礼让：让当前线程退出CPU资源
		}
	}
}

测试类

package com.dream.test07;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 线程的礼让
		 * 
		 * 需求：创建两个线程A,B，分别各打印1-100的数字，
		 * 其中B一个线程，每打印一次，就礼让一次，观察实验结果
		 */
		
		A a = new A();
		B b = new B();
		
		a.start();
		b.start();
	}
}

十三、线程的合并 join

x) 主线程和子线程同时运行，满足一定条件后，让子线程先运行至结束
y) 练习：主线程和子线程各打印200次，从1开始每次增加1，当主线程打印到10之后，让子线程先打印完再打印主线程
MyThread类

package com.dream.test08;

public class MyThread extends Thread {

	@Override
	public void run() {
		for (int i = 1; i <= 200; i++) {
			System.out.println("子线程：" + i);
		}
	}
}

测试类

package com.dream.test08;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 线程的合并
		 * 
		 * 需求：主线程和子线程各打印200次，从1开始每次增加1，
		 * 当主线程打印到10之后，让子线程先打印完再打印主线程
		 */
		
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <= 200; i++) {
			System.out.println("主线程：" + i);
			if(i == 10){
				try {
					t.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

十四、线程的中断

z) Interrupt
thread.interrupt();//改变线程中断值
Thread.currentThread().isInterrupted()//取反
aa) 设置开关变量
MyThread类

package com.dream.test09;

public class MyThread extends Thread{

	@Override
	public void run() {
		//Thread.currentThread().isInterrupted() 获取当前线程的状态
		//false - 没有消亡
		//true  - 消亡
		while(!Thread.currentThread().isInterrupted()){
			
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
		}
	}
}

测试类

package com.dream.test09;

public class Test01 {
	
	public static void main(String[] args) throws InterruptedException {
		/**
		 * 线程的中断
		 */
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(1000);
		
		t.interrupt();//改变线程状态
	}
}

十五、守护线程

MyThread类

package com.dream.test10;

public class MyThread extends Thread{

	@Override
	public void run() {
		while(true){
			System.out.println("守护线程默默守护着前台线程");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

测试类

package com.dream.test10;

public class Test01 {
	
	public static void main(String[] args) throws InterruptedException {
		/**
		 * 守护线程/后台线程：
		 * 理解：守护线程默默守护着前台线程，所有的前台线程死亡后，守护线程会自动销毁
		 */
		
		MyThread t = new MyThread();
		t.setDaemon(true);//设置该线程为守护线程
		t.start();
		
		for (int i = 1; i <= 5; i++) {
			System.out.println("主线程：" + i);
			Thread.sleep(1000);
		}
		
	}

}

十六、线程局部变量（实现线程范围内的共享变量）

线程范围类的共享：把变量（int i）共享给run方法里所有的对象
共享一个变量
A类

package com.dream.test11;

public class A {
	
	public void println(){
		
		Thread t = Thread.currentThread();
		Integer value = Test01.map.get(t);
		System.out.println(t.getName() + "线程中的A类对象共享的变量：" + value);
		
	}

}

B类

package com.dream.test11;

public class B {
	
	public void println(){
		Thread t = Thread.currentThread();
		Integer value = Test01.map.get(t);
		System.out.println(t.getName() + "线程中的B类对象共享的变量：" + value);
	}

}

测试类

package com.dream.test11;

import java.util.concurrent.ConcurrentHashMap;

public class Test01 {
	
	public static ConcurrentHashMap<Thread, Integer> map = new ConcurrentHashMap<>();
	
	public static void main(String[] args) {
		/**
		 * 线程的局部变量共享
		 * 
		 * 共享一个变量
		 */
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 10;
				
				//存数据
				map.put(Thread.currentThread(), i);
				
				A a = new A();
				B b = new B();
				
				a.println();//10
				b.println();//10
				
			}
		}, "线程1").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 20;
				
				//存数据
				map.put(Thread.currentThread(), i);
				
				A a = new A();
				B b = new B();
				
				a.println();//20
				b.println();//20
			}
		}, "线程2").start();
		
	}
}

共享多个变量 – ConcurrentHashMap
A类

package com.dream.test12;

public class A {
	
	public void println(){
		
		Thread t = Thread.currentThread();
		Data value = Test01.map.get(t);
		System.out.println(t.getName() + "线程中的A类对象共享的变量：" + value);
		
	}

}

B类

package com.dream.test12;

public class B {
	
	public void println(){
		Thread t = Thread.currentThread();
		Data value = Test01.map.get(t);
		System.out.println(t.getName() + "线程中的B类对象共享的变量：" + value);
	}

}

Data类

package com.dream.test12;

//数据包
public class Data {
	
	private String str;
	private int i;
	
	public Data() {
	}
	
	public Data(String str, int i) {
		this.str = str;
		this.i = i;
	}

	public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	@Override
	public String toString() {
		return str + " -- " + i;
	}
	
	
	
	
	

}

测试类

package com.dream.test12;

import java.util.concurrent.ConcurrentHashMap;

public class Test01 {
	
	public static ConcurrentHashMap<Thread, Data> map = new ConcurrentHashMap<>();
	
	public static void main(String[] args) {
		/**
		 * 线程的局部变量共享
		 * 
		 * 共享多个变量
		 */
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = new Data("线程1里的字符串", 10);
				
				//存数据
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				
				a.println();//10
				b.println();//10
				
			}
		}, "线程1").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				Data data = new Data("线程2里的字符串", 20);
				
				//存数据
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				
				a.println();//20
				b.println();//20
			}
		}, "线程2").start();
		
	}
}

共享多个变量 – ThreadLoacl
A类

package com.dream.test13;

public class A {
	
	public void println(){
		
		Thread t = Thread.currentThread();
		Data value = Test01.local.get();
		System.out.println(t.getName() + "线程中的A类对象共享的变量：" + value);
		
	}

}

B类

package com.dream.test13;

public class B {
	
	public void println(){
		Thread t = Thread.currentThread();
		Data value = Test01.local.get();
		System.out.println(t.getName() + "线程中的B类对象共享的变量：" + value);
	}

}

Data类

package com.dream.test13;

//数据包
public class Data {
	
	private String str;
	private int i;
	
	private Data() {
	}
	
	private Data(String str, int i) {
		this.str = str;
		this.i = i;
	}
	
	//保证一个线程只有一个数据包对象
	//获取当前线程中的Data对象
	public static Data getInstance(String str,int i ){
		
		Data data = Test01.local.get();
		if(data == null){
			data = new Data(str, i);
			Test01.local.set(data);
		
		}else{
			data.setStr(str);
			data.setI(i);
		}
		
		return data;
		
	}

	public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	@Override
	public String toString() {
		return str + " -- " + i;
	}
	
	
	
	
	

}

测试类

package com.dream.test13;

public class Test01 {
	
	public static ThreadLocal<Data> local = new ThreadLocal<>();
	
	public static void main(String[] args) {
		/**
		 * 线程的局部变量共享
		 * 
		 * 共享多个变量 -- ThreadLoacl
		 */
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = Data.getInstance("线程1里的字符串1", 10);
				data = Data.getInstance("线程1里的字符串2", 666);

				
				//存数据
				local.set(data);
				
				A a = new A();
				B b = new B();
				
				a.println();//10
				b.println();//10
				
			}
		}, "线程1").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				Data data = Data.getInstance("线程2里的字符串1", 20);
				data = Data.getInstance("线程2里的字符串2", 888);
				
				//存数据
				local.set(data);
				
				A a = new A();
				B b = new B();
				
				a.println();//20
				b.println();//20
			}
		}, "线程2").start();
		
	}
}

十七、经典面试题：线程的生命周期

MyThread t = new MyThread();
t.start();
//调度运行状态–run
//run sleep–阻塞–

a) 新建状态
i. 在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的内存空间和其它资源，但还处于不可运行状态。新建一个线程对象可采用线程构造方法来实现。
ii. 例如：Thread thread=new Thread();
b) 就绪状态
i. 新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU调用，这表明它已经具备了运行条件。
c) 运行状态
i. 当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。
d) 阻塞状态
i. 一个正在执行的线程在某些特殊情况下，如被人为挂起，将让出CPU并暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(2000)、wait()等方法，线程都将进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。
e) 死亡状态
i. 线程调用stop()方法时或run()方法执行结束后，线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

思考：
a) 计算任务，一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。

b) 铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，请编写多线程程序来模拟这个效果
i. 窗口001正在销售第1000张票
ii. 窗口001正在销售第999张票
iii. 窗口002正在销售第998张票
iv. 。。。
v. 窗口002正在销售第1张票
vi. 票已经销售完毕