线程：还会涉及到一些名词概念：
程序，进程，线程，多进程，多线程
进程中所包含的一个或多个执行单元称为线程，一个线程就是进程中的一个顺序执行流。
进程拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。即同一个进程
中的多个线程共享一块内存空间和一组系统资源。
线程只能归属于一个进程并且它只能访问该进程所拥有的资源。
线程本身也有一个供程序执行时的堆栈，在线程切换时，负荷小，因此线程也被称之为轻
负荷进程。
并发原理
多个线程"同时运行"只是我们感官上的一种表现。其实，线程是并发运行的。
操作系统将时间划分成很多时间片段，尽可能的均匀分配给每一个线程，获取时间片段
的线程被CPU运行，而其他线程处于等待状态。所以这种微观上是走走停停，断断续续
的，宏观上都在运行的现象叫并发。
但不是绝对意义上的"同时发生"。
进程：是一个运行中的程序的实例。
进程的两个特点：
(1)是一个实体，都有自己独立的地址空间，分为文本区域，数据区域和堆栈。
文本区域用来存储编写的程序的代码，数据区域用来存储运行时所需要的
数据(动态分配的内存)，堆栈用来存储运行时涉及到的指令和本地变量
(2)是一个"运行中的程序"，程序本身是一个没有生命的实体，只有当处理器
赋予它生命时，它才能称之为一个活动的实体，即进程。
进程是操作系统级别的基本单元。
通俗点说：进程就是操作系统运行的一个任务(一个应用程序运行时，就对应一个进程)
程序，进程，线程，多进程，多线程
(1)程序：可以实现多个功能的代码体。也叫软件。
(2)进程：有两个特点
-- 是一个实体：有自己的地址空间，如文本区域，数据区域，堆栈区域
-- 是一个运行中的程序,cpu赋予程序生命时，就是一个进程。
进程是操作系统的一个任务
(3)线程:是进程里的一个任务，是一个顺序执行流。
有自己独立的堆栈，与其他线程共享进程的地址空间
(4)多进程：针对于古老的操作系统来说，现在的操作系统都是多进程的。
可以同时运行多个程序
(5)多线程:一个进程中的多个任务，可以同时进行多个顺序执行流。
好处:
1)提高cpu的资源利用率
2)可以共享同一个资源(静态资源，同一个对象实例)
线程的状态图解析：
(1) 新建状态： 即新建一个线程对象，设置好需要执行的任务
(2) 就绪状态: 调用线程的start方法，进入准备状态,等待cpu分配时间片段
(3) 运行状态： 当cpu将时间片段给了线程对象后，线程开始执行任务。
(4) 阻塞状态：正在运行中的线程由于某种原因，放弃了cpu的使用权
即该线程放弃时间片段，进入阻塞状态。
阻塞状态分为三种：
等待阻塞: 运行中的线程调用wait方法时，jvm将
此线程放入等待池中
同步阻塞:运行中的线程想要获取同步的锁对象时，如果锁对象被其他占用，
则，jvm将此线程放入锁池中
其他阻塞: 当线程中执行到阻塞方法或者是Thread.sleep()或者是其他线程的join
时，该线程进行阻塞状态
(5) 当线程执行完任务后，表示结束。
线程的创建方式(3种)
(1)继承Thread类，重写run方法，定义任务内容。然后调用
start方法，用于启动线程。(切记，不是调用run方法)
(2)实现接口Runnable，重写run方法，定义任务内容，然后将任务
传给Thread对象，然后由Thread调用start方法，执行任务
(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)
创建一个指定名称的线程对象
常用方法：
long getId() 返回此线程的ID
String getName()返回此线程的名称
int getPriority()返回此线程的优先级
Thread.State getState() 返回此线程的状态
boolean isAlive() 测试这个线程是否活着
boolean isDaemon()测试这个线程是否是守护线程
void setDaemon(boolen on) 形参填true的话，表示设置为守护线程
void setPriority(int newPriority)更改此线程的优先级
练习:
桌子上总共有20个豆子，有两个人来取豆子，每个人每次只
能取一个豆子。并输出桌子上剩余的豆子数。
线程调度：
多线程时，谁先执行是不可控的，是由cpu的线程调度来分配的。
但是我们可以通过线程的优先级来尽可能的让线程调度来调控线程
所需要的时间片段
线程的优先级：
1-10，10为最高级别，1为最低级别，5为默认级别
Thread.MIN_PRIORITY--最小优先级
Thread.MAX_PRIORITY--最高优先级
Thread.NORM_PRIORITY--默认优先级
守护线程：线程分两类，一类是普通线程(前台线程)，
一类是守护线程(后台线程)。
当线程只剩下守护线程后，所有线程都结束。
static sleep(long time):
线程的静态方法，用于使当前线程进入阻塞状态，时间为time毫秒。
time毫秒后，会进入就绪状态。如果期间被打断，会出现异常
InterruptException
void interrupt()
打断阻塞状态下的线程对象。
join()：
作用是将当前线程插入到某一个线程中，使某一个线程进入阻塞状态。
当前线程执行完后，另一个线程进入就绪状态。
static void yield()
线程对象让步的功能：让出时间片段，此线程进入就绪状态。
同步锁：
当多个线程操作临界资源时，可能会出现线程安全隐患问题。
临界资源可能是：
(1)某一个静态变量
(2)某一个实例变量
如果想解决这样的问题，需要使用同步操作。
异步操作：多线程的并发操作，相当于各干各的
同步操作：相当于一个做完，另一个再做。
线程在内部提供了一个内置的锁机制保证原子性，用于线程进行同步操作。
锁需要两点：
(1) 锁是一个对象，
(2) 如果想进行同步，多个现象操作的必须是同一个锁
synchronized(锁对象的引用){
需要同步的代码块
}
锁机制：当一个线程进入同步的代码块后,就会获得锁对象的使用权。其他线
程如果执行到此处，会发现锁对象被占用，只能处于等待状态(锁池)，
当线程执行完同步的代码后或者出现异常，都会自动释放锁。
合适的锁对象：
必须是一个引用类型，而且必须使多个线程都可以使用这个锁对象，
因此this对象比较适合
同步代码块的范围:
(1)可以是方法内的一部分代码，可以也是全部代码(相当于给方法上了锁)
(2)成员方法上添加修饰词synchronized,锁对象为this
如果一个类的所有成员方法都使用了同步关键字，当某一个线程
操作了其中一个方法，另外的线程即使操作的不是这个方法，
也会进入锁池状态
(3)静态方法上也可以添加synchronized，锁对象为类对象，
调用方法：类名.class，每一种类都有一个唯一的类对象
wait()/notify()notifyAll():
上述的方法都是Object类型提供的，用来调控线程的状态的。
使用位置必须是同步块中，如果不是同步块中，会报异常
wait():
当前获取锁对象的线程准备释放锁，给其他线程获取锁的机会。
wait(long time):
当前获取锁对象的线程如果没有被通知，在延迟time毫秒后，自动释放锁对象
wait(long time,int naons):
功能一样，只不过比上一个方法延迟的时间更加精确。
notify()/notifyAll():
当前获取锁对象的线程准备释放锁，使用此方法通知处于使用wait方法等待的线程，
natify():只会随机通知等待线程中的其中一个。
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)
创建一个线程池，可以进行设置延迟或者是定时来执行任务
4 24 4 1 4