*线程：
还会涉及到一些名词概念：
(程序，进程，线程，多进程，多线程，并发)
--进程： 是一个运行中的程序的实例。
--多进程：多个进程同时运行
进程的两个特点：
(1)是一个实体，都有自己独立的地址空间，分为文本区域，数据区域和堆栈。
文本区域用来存储编写的程序的代码，
数据区域用来存储运行时所需要的数据(动态分配的内存)，
堆栈用来存储运行时涉及到的指令和本地变量
(2)是一个"运行中的程序"，程序本身是一个没有生命的实体，只有当处理器
赋予它生命时，它才能称之为一个活动的实体，即进程。
进程是操作系统级别的基本单元。
通俗点说：进程就是操作系统运行的一个任务(一个应用程序运行时，就对应一个进程)
--线程的状态图解析：
(1) 新建状态: 即新建一个线程对象，设置好需要执行的任务
(2) 就绪状态: 调用线程的start方法，进入准备状态,等待cpu分配时间片段
(3) 运行状态: 当cpu将时间片段给了线程对象后，线程开始执行任务。
(4) 阻塞状态: 正在运行中的线程由于某种原因，放弃了cpu的使用权
即该线程放弃时间片段，进入阻塞状态。
阻塞状态分为三种：
1)等待阻塞: 运行中的线程调用wait方法时，jvm将此线程放入等待池中
2)同步阻塞: 运行中的线程想要获取同步的锁对象时，如果锁对象被其他占用，
则，jvm将此线程放入锁池中
3)其他阻塞: 当线程中执行到阻塞方法/Thread.sleep()/其他线程的join时，
该线程进行阻塞状态
(5) 当线程执行完任务后，表示结束。
--线程的创建方式(3种)
(1)继承Thread类，重写run方法(线程的任务体)，定义任务内容。
然后调用start方法，用于启动线程。(切记，不是调用run方法)
(2)实现接口Runnable，重写run方法，定义任务内容，
然后将任务传给Thread对象，再由Thread调用strat方法，执行任务
(3)使用FutureTask创建线程，再使用Callable创建子类任务，
重写call方法(相当于run方法)，再将Callable对象传给FutureTask,
再将FutureTask对象传给Thread对象，
调用start方法，启动线程
第二种方式与第一种比较:
(1)将线程对象和任务对象分开，降低了耦合度，便于维护
(2)避免了java中单继承的限制
(3)适合相同的任务代码块处理同一个资源
第三种方式: call方法带有返回值。
--线程API:
常用构造器：
Thread(Runnable r): 创建一个指定任务的线程对象
Thread(Runnable r,String name): 创建一个指定任务，并且指定名称的线程对象
Thread(String name): 创建一个指定名称的线程对象
常用方法： 下面有
练习:
桌子上总共有20个豆子，有两个人来取豆子，每个人每次只
能取一个豆子。并输出桌子上剩余的豆子数。
--线程的优先级：
1-10，10为最高级别，1为最低级别，5为默认级别
Thread.MIN_PRIORITY--最小优先级
Thread.MAX_PRIORITY--最高优先级
Thread.NORM_PRIORITY--默认优先级
--守护线程：(调用setDaemon()方法)
线程分两类:
1)普通线程(前台线程)
2)守护线程(后台线程)
当线程只剩下守护线程后，所有线程都结束。
------------------------------------------------------------------------------------------------------------------------
static sleep(long time):
线程的静态方法，用于使当前线程进入阻塞状态，时间为time毫秒。
time毫秒后，会进入就绪状态。如果期间被打断，会出现异常
InterruptException
join():
作用是将当前线程插入到某一个线程中，使某一个线程进入阻塞状态。
当前线程执行完后，另一个线程进入就绪状态。
=========================================================================================================
程序，进程，线程，多进程，多线程
(1)程序：可以实现多个功能的代码体。也叫软件。
(2)进程：有两个特点
--是一个实体：有自己的地址空间，如文本区域，数据区域，堆栈区域
--是一个运行中的程序,cpu赋予程序生命时，就是一个进程。
进程是操作系统的一个任务
(3)线程:是进程里的一个任务，是一个顺序执行流。
有自己独立的堆栈，与其他线程共享进程的地址空间
(4)多进程：针对于古老的操作系统来说，现在的操作系统都是多进程的。
可以同时运行多个程序
(5)多线程:一个进程中的多个任务，可以同时进行多个顺序执行流。
好处:
1)提高cpu的资源利用率
2)可以共享同一个资源(静态资源，同一个对象实例)
----------------------------------------------------------------------------------------------------------------------
*并发原理：
cpu在一个时间片段里，只能做一件事。微观上，cpu是将时间细分成
很多个小的时间片段,尽可能的将时间片段平均分给多个线程，所以
针对于某一个线程来说，是走走停停，断断续续的。但是在宏观上，
人类感觉不出，看似是这些线程是同时进行的，这就是并发原理。
线程并发出现在多线程中。
--线程的三种创建方式：
(1)继承Thread类，重写run方法，调用start方法，启动线程进入就绪状态
(2)实现Runnable接口，重写run方法，传给Thread对象....
(3)创建Callable的子类对象，重写call方法，传给FutureTask对象，再将
FutureTask对象传给Thread对象,.........
--线程的状态：
(1)新建状态: 线程的创建(任务的确定)
(2)就绪状态: 调用start()
(3)运行状态: cpu将时间片段给线程，执行run方法里的任务逻辑
(4)阻塞状态: 线程放弃cpu的时间片段，进入阻塞。
等待阻塞: wait()
同步阻塞: 要获取的锁对象，已经被占用。当前线程等待其他线程释放锁对象
其他阻塞: sleep()，join(),其他类的阻塞方法(sc.nextInt())
(5)死亡状态: 线程任务结束或者由于异常造成的run方法停止。
--常用构造器:
Thread(String name);
Thread(Runnable r)
Thread(Runnable r,String name)
--常用方法：
String getName()
long getId()
int getPriority()
State getState()
boolean isAlive()
boolean isDaemon()
boolean isInterrupt();
static Thread currentThread():返回当前正在运行的对象的引用
--线程调度：
多线程时，谁先执行是不可控的，是由cpu的线程调度来分配的。
但是我们可以通过线程的优先级来尽可能的让线程调度来调控线程
所需要的时间片段。
优先级:从1-10，越来越高。
1是最低的优先级: 对应的常量:MIN_PRIORITY
10是最高的优先级: 对应的常量:MAX_PRIORITY
5是默认的优先级: 对应的常量:NORM_PRIORITY
对应的方法:
void setPriority(int priority)
int getPriooity();
--守护线程：
线程共分两大类：
1）普通线程(前台线程)
2）守护线程(后台线程)
在只剩下守护线程时，会结束所有线程。
方法：
void setDaemon(boolean flag):
设置为true时,是守护线程
static void sleep(long time):
使当前线程放弃时间片段，进入阻塞状态，超时后，会进入就绪状态。
如果没有超时，而是被打断，会出现检查性异常:InterruptException
void interrupt():
打断阻塞状态下的线程对象。
void join():
将当前线程A加入到线程B中，线程B进入阻塞状态，
直到线程A结束，线程B进入就绪状态，等待被分配时间片段。
练习:
两个线程A和B:
线程A的任务是计算1到100的和。
线程B的任务是获取线程A计算的结果。
static void yield():
线程对象让步的功能：让出时间片段，此线程进入就绪状态。
=======================================================================
*同步锁：
当多个线程操作临界资源时，可能会出现线程安全隐患问题。
临界资源可能是：
(1)某一个静态变量
(2)某一个实例变量
如果想解决这样的问题，需要使用同步操作。
--异步操作：多线程的并发操作，相当于各干各的
--同步操作：相当于一个做完，另一个再做。
线程在内部提供了一个内置的"锁机制"保证原子性，用于线程进行同步操作。
--锁需要两点：
(1)锁是一个对象，
(2)如果想进行同步，多个线程操作的必须是“同一个锁”
synchronized(锁对象的引用){
需要同步的代码块
}
--锁机制：
当一个线程进入同步的代码块后,就会获得锁对象的使用权。
其他线程如果执行到此处，会发现锁对象被占用，只能处于等待状态(锁池)，
当线程执行完同步的代码块后或者出现异常，都会自动释放锁。
--合适的锁对象：
必须是一个引用类型，而且必须使多个线程都可以使用这个锁对象，
因此this对象比较适合
--------------------------------------------------------------------------------------------------------------------------------
--同步方法:给方法上锁
--同步代码块的范围:
(1)可以是方法内的一部分代码，可以也是全部代码(相当于给方法上了锁)
(2)成员方法上添加修饰词synchronized,锁对象为this
如果一个类的所有成员方法都使用了同步关键字，
当某一个线程操作了其中一个方法，另外的线程即使操作的不是这个方法，
也会进入锁池状态
(3)静态方法上也可以添加synchronized，锁对象为类对象，
"调用方法：类名.class，每一种类都有一个唯一的类对象"
*同步代码块内：
(1)尽可能的不要使用sleep()和yield()，
因为比较占cpu资源
(2)同步块越小越好，省cpu的资源
---------------------------------------------------------------------------------------------------------------------------------
--wait() / notify(),notifyAll():
上述的方法都是Object类型提供的，用来调控线程的状态的。
使用位置必须是同步块中，如果不是同步块中，会报异常
wait():
当前获取锁对象的线程准备释放锁，给其他线程获取锁的机会。
wait(long time):
当前获取锁对象的线程如果没有被通知，在延迟time毫秒后，自动释放锁对象
wait(long time,int naons):
功能一样，只不过比上一个方法延迟的时间更加精确。
notify()/notifyAll():
当前获取锁对象的线程准备释放锁，使用此方法通知处于使用wait方法等待的线程，
notify():
只会随机通知等待线程中的其中一个。
notifyAll():
通知所有等待的线程来竞争锁。
=======================================================================
*生产者--消费者--仓库模式：此模式脱离了仓库没有任何意义。
(1)仓库用来存储数据。
(2)仓库不满的情况下，生产者可以生产
(3)仓库中满足消费者的需求时，消费者就可以消费
/*作业1:
第一个线程输出1,2,3,4,5
第二个线程输出6,7,8,9,10
第三个线程输出11,12,13,14,15
第一个线程输出16,17,18,19,20
第二个线程输出..........
第三个线程输出........
直到输入75停止。
作业2:
模拟小张一家四口(小张，小张媳妇，小张他爸，小张他妈)
分别拿着小张的银行卡去银行存取钱。
*/
===============================================================================================================================================================================================
===================================================
前提：有多个线程时
并发操作:多个线程同时开启，微观上断断续续，宏观上同时发生
断断续续：同一个方法内的两行代码不一定是两个挨着的时间片段
同步操作:在并发的基础上，同一个方法内的两行代码执行时间片段
可以不挨着，但是其他线程不能对这两行代码的执行权 ，
保证了代码的原子性。即这两行代码是同步的，当前线程执行完后，
其他线程才有执行权。
想实现同步操作，提供了一个锁机制:
我们将需要同步的代码加上一个内置锁对象，当某一个线程
执行到此代码时，会获取锁对象，其他线程需要等待。当获取锁对象的
线程执行完同步块(或者是因为异常)都会释放锁对象。其他线程
通过cpu的线程调用才有机会获取锁对象的使用权
synchronized(锁对象){
}
锁对象：多个线程一定要使用同一个锁，否则没有记性同步操作
========================================================================
*线程池：
(1)如果每个任务都需要创建线程对象，内存开销大
(2)方便管理线程对象。
--线程池的原理: 就是一些线程的集合，
线程的状态不是死亡状态，
当线程池接收外面的任务时，
线程池的管理器会查看是否有空闲线程，
如果有,就会将任务分配给它，
如果没有，任务处于等待队列中.
--线程池的类型：ExecutorService
另外一个类Executors里提供了多个静态方法，
来获取线程池对象
方法1：
newSingleThreadExecutor()：
获取单个线程的线程池对象，内部维护了一个无界队列用于存储任务
方法2:
newFixedThreadPool(int nThreads):
创建一个固定数量线程的线程池，维护一个为无界队列
方法3:
newCachedThreadPool():
创建一个可以根据需求来创建新线程的线程池对象，
如果有可重用的，会优先使用。
方法4:
newScheduledThreadPool(int corePoolSize):
创建一个线程池，可以进行设置延迟或者是定时来执行任务