Java多线程知识点总结

知识点

package 线程相关概念;
/*
程序-进程-线程
程序：指令集-静态的概念
进程：操作系统调度程序-动态概念
作为资源分配的单位
每个进程都有独立的代码和数据空间，进程切换开销较大
在操作系统中能同时运行多个任务
系统运行时为每个进程分配不同的内存区域
没有进程的线程被称为单线程，一个进程有多个线程称为多线程，多条线程同时进行
线程：在进程内多条执行路径
调度和执行的单位
线程可以看成轻量级进程，同一个类的线程共享代码和数据空间
每个线程有独立的运行栈和程序计数器（pc）线程切换开销较小
同一应用程序有多个顺序流同时执行
出cpu以外不会为线程分配内存，线程组只能共享资源
线程时进程的一部分，被称为轻量级进程

	使用多线程
		1，继承 Thread 
		 	1，创建多线程 继承 Thread 重写run（线程体）
	 		2，使用线程：直接创建子类对象，调用对象的start方法，线程启动
		2，实现Runnable接口--避免了单继承
			使用Runnable创建多线程
				1，类实现Runnable接口+重写run方法---》真实角色类
				2,启动多线程，使用静态代理模式
					1，创建真实角色
					2，创建代理角色+真实角色的引用
					3，调用Start方法，启动线程
		3，推荐使用Runnable接口--
			避免了单继承
			便于共享资源
			
		4，使用Callable接口
			有返回值
			可以抛出异常
			需要重写call方法
			使用
				1）创建Callable接口，重写call方法
				2）借助执行调度服务ExecutorService获取Future对象
				ExecutorService src=new Executors.newFixedThreadPool(2);
				Future result=src.submit(实现类对象）
				3）获取值result.get();
				4)暂停服务src.shutdownNow()
				
	线程状态
		1，新生状态
			使用new关键字和Thread类及其子类创建一个线程后，该线程是新生状态
			有自己的内存空间，调用start方法进入就绪状态
		2，就绪状态
			处于就绪状态就有了运行的条件但还没有分配到cpu，处于线程就绪状态
			等待系统分配CPU，当系统选定一个等待执行的Thread对象后，他从等待状态转为执行状态
			系统挑选的动作成为CPU的调度，被选中的线程，开始执行run方法
		3，运行状态
			在运行状态的线程执行自己的run方法，知道调用其它方法而终止、或等待某资源而阻塞
			或完成任务而死亡，如果在给定时间片里没有完成则会转为阻塞状态
		4，阻塞状态
			在运行状态的线程，执行了run方法或等待IO设备将让出cpu并暂时停止自己的线程进入阻塞状态
			在阻塞状态的线程不能进入就绪队列，只有等阻塞原因被消除后才能进入就绪队列，等待被选中
		5，死亡状态
			死亡状态是线程生命周期中的最后一个阶段，线程死亡原因有：一正常运行的线程完成了他所有工作
			2，线程被强制性终止，如执行stop或destroy方法来终止一个线程（前者会产生异常，后者不会释放锁）
		停止线程
			1，自然终止：线程体正常执行完毕
			2，外部干涉
				1，线程类中定义 线程体使用的标识
				2，线程体使用标识
				3，提供对外的方法改变标识
				4，外部根据条件调用该方法
			
		阻塞
			1 join：合并线程
				join() 
				等待这个线程死亡。  
				void join(long millis) 
				等待这个线程死亡最多 millis毫秒。  
				void join(long millis, int nanos) 
				等待最多 millis毫秒加上 nanos纳秒这个线程死亡。 
			2 yield：暂停自己的线程
				yield() 
				对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。 
			3 sleep:休眠，不会释放锁
				用于与时间相关的：倒计时 或者 用于模拟网络延迟
				sleep(long millis) 
				使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），
				具体取决于系统定时器和调度程序的精度和准确性。  
				sleep(long millis, int nanos) 
				导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），
				这取决于系统定时器和调度器的精度和准确性。  
				
			测试方法
				static Thread currentThread() 
				返回对当前正在执行的线程对象的引用。  
				getName() 
				返回此线程的名称。 
				setName(String name) 
				将此线程的名称更改为等于参数 name 。 
				isAlive() 
				测试这个线程是否活着。 
				
	优先级代表的是概率，不代表绝对的先后顺序
		MAX_PRIORITY 10
		线程可以拥有的最大优先级。  
		NORM_PRIORITY 5
		分配给线程的默认优先级。  
		MIN_PRIORITY 1
		线程可以拥有的最小优先级。  
		
	同步：方法锁
		并发 多个线程访问同一个资源，确保资源安全--》线程安全的类
		synchronized-->线程安全--》方法锁
		
		1，同步块
		synchronized（引用类型||this||类。class）{
		}
		2，同步方法
	
	死锁：过多的同步会造成死锁
		
		
	单例设计模式：
		确保一个类只有一个对象，在内部创建对象，外部只能调用
		懒汉式方法
			1，构造器私有化，避免外部创建对象
			2，声明一个私有的静态变量
			3，创建一个对外的公共的静态方法，访问该变量，如果变量没有对象，则创建该对象
		饿汉式
			1，构造器私有化，避免外部创建对象
			2，声明一个私有的静态变量，并创建该对象
			3，创建一个对外的公共的静态方法，访问该变量
		
	生产者消费模式：解决死锁的方案
		解决该问题，要让生产者在缓存区满的时候休眠，等到消费者消耗缓存区数据的时候
		生产者才能被唤醒，开始放缓存区添加数据，同时，等到生产者往缓存区添加数据
		才能唤醒消费者，通常的方法有，信号灯法，管程法
		
		信号灯法
		
		方法
		notify() 
		唤醒正在等待对象监视器的单个线程。  
		void notifyAll() 
		唤醒正在等待对象监视器的所有线程。  
	
		 wait() -->释放锁
		导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。  
		void wait(long timeout) 
		导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，
		或者指定的时间已过。  
		void wait(long timeout, int nanos) 
		导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，
		或者某些其他线程中断当前线程，或一定量的实时时间。  
		
		wait和notify 必须和同步一起使用，不然不能使用
		
	任务调度：计时器
		两个类
		1，TimerTask线程类，抽象类，要实现run方法
		public abstract class TimerTask extends Object implements Runnable
		2，Timer类
		主要方法：
			schedule(TimerTask task, Date time) 
			在指定的时间安排指定的任务执行。  
			void schedule(TimerTask task, Date firstTime, long period) 
			从指定 的时间开始 ，对指定的任务执行重复的 固定延迟执行 。  
						
	静态代理模式
		1，真实角色
		2，代理角色
		3，二者实现相同的接口

线程总结
一，创建线程（重点）
1，继承Thread类，重写run方法
2，实现Runnable接口，重写run方法
3，实现Callable（了解）
二，线程的状态
1，新生–》start–》就绪–》运行–》阻塞–》终止
2，终止线程（重点）
3，阻塞：join||yield||sleep
三，线程的信息
1，Thread.currentThread
2,获取名称，设置名称
3，设置优先级，判断状态
四，同步–同一份资源
块synchronized（应用类型变量||类。class||this）{
}
方法 synchronized
过多的同步会造成死锁
单例设计模式
五，生产者消费模式
信号灯法
管程法
六，任务调度
Timer类
TimerTask类

可以自学juc

*/