线程

一、程序：可以实现多个功能的代码体。也叫软件。       
二、进程：是一个运行中的程序的实例。          
       进程的两个特点：
       (1)是一个实体，都有自己独立的地址空间，分为文本区域，数据区域和堆栈。
              文本区域用来存储编写的程序的代码，数据区域用来存储运行时所需要的
              数据(动态分配的内存)，堆栈用来存储运行时涉及到的指令和本地变量
       (2)是一个"运行中的程序"，程序本身是一个没有生命的实体，只有当处理器
             赋予它生命时，它才能称之为一个活动的实体，即进程。
    进程是操作系统级别的基本单元。
    通俗点说：进程就是操作系统运行的一个任务(一个应用程序运行时，就对应一个进程) 

三、线程：
    进程中所包含的一个或多个执行单元称为线程（thread）。一个线程就是进程中的一个顺序执行流。
    进程拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问，即同一个进程中的多个线程共享一块内存空间和一组系统资源。
    线程只能归属于一个进程并且它只能访问该进程所拥有的资源。
    线程本身也有一个供程序执行时的堆栈，在线程切换时，负荷小，因此线程也被称之为轻负荷进程。
    
四、多进程：针对于古老的操作系统来说，现在的操作系统都是多进程的。可以同时运行多个程序
五、多线程:一个进程中的多个任务，可以同时进行多个顺序执行流。
               好处:  
               (1)提高cpu的资源利用率
               (2)可以共享同一个资源(静态资源，同一个对象实例)
六、并发原理：
    多个线程“同时运行”只是我们感官上的一种表现。其实，线程是并发运行的。
    操作系统将时间划分成很多时间片段，尽可能的均匀分配给每一个线程，获取时间片段的线程被CPU运行，
    而其他线程处于等待状态。所以这种微观上是走走停停，断断续续的，宏观上都在运行的现象叫并发。
    但不是绝对意义上的“同时发生”。

七、线程的状态图解析：
(1) 新建状态： 即新建一个线程对象，设置好需要执行的任务
(2) 就绪状态: 调用线程的start方法，进入准备状态,等待cpu分配时间片段
(3) 运行状态： 当cpu将时间片段给了线程对象后，线程开始执行任务。
(4) 阻塞状态：正在运行中的线程由于某种原因，放弃了cpu的使用权
                            即该线程放弃时间片段，进入阻塞状态。
         阻塞状态分为三种：
         等待阻塞: 运行中的线程调用wait方法时，jvm将此线程放入等待池中   
         同步阻塞:运行中的线程想要获取同步的锁对象时，如果锁对象被其他占用，则，jvm将此线程放入锁池中
         其他阻塞: 当线程中执行到阻塞方法(sc.nextInt)或者是Thread.sleep()或者是其他线程的join时，该线程进行阻塞状态
(5) 死亡状态: 线程任务结束或者由于异常造成的run方法停止。

八、线程的创建方式(3种)
   (1)继承Thread类，重写run方法，定义任务内容。然后调用
       start方法，用于启动线程。(切记，不是调用run方法)
   (2)实现接口Runnable，重写run方法，定义任务内容，然后将任务
       传给Thread对象，然后由Thread调用start方法，执行任务
   (3)创建Callable的子类对象，重写call方法(相当于run方法)，传给FutureTask对象，再将
       FutureTask对象传给Thread对象，调用start方法，启动线程  
      
 第二种方式与第一种比较，
 (1)将线程对象和任务对象分开，降低了耦合度，便于维护     
 (2)避免了java中单继承的限制
 (3)适合相同的任务代码块处理同一个资源
 第三种方式:call方法带有返回值。
 
九、常用构造器：
                Thread(Runnable r)                            创建一个指定任务的线程对象 
                Thread(Runnable r,String name)        创建一个指定任务，并且指定名称的线程对象      
                Thread(String name)                        创建一个指定名称的线程对象
     常用方法：
                String getName()
                long getId()
                int  getPriority()
                State getState()
                boolean isAlive()
                boolean isDaemon()
                boolean isInterrupt(); 

    
十、线程调度：
     多线程时，谁先执行是不可控的，是由cpu的线程调度来分配的。但是我们可以通过线程的优先级来尽可能的让线程调度来调控线程所需要的时间片段。 
       
    线程的优先级：
    1-10，10为最高级别，1为最低级别，5为默认级别
    Thread.MIN_PRIORITY--最小优先级--1
    Thread.MAX_PRIORITY--最高优先级--10
    Thread.NORM_PRIORITY--默认优先级--5

    对应的方法：
    void  setPriority(int priority)

十一、守护线程(setDaemon(true))：
          线程分两类，一类是普通线程(前台线程)，一类是守护线程(后台线程)。
          多线程程序，在只剩下守护线程时，会结束所有线程。
            
          方法：
                void setDaemon(boolean flag)
                设置为true时，是守护线程。 
 
十二、           
    static void sleep(long time):
        线程的静态方法，使当前线程放弃时间片段，进入阻塞状态，时间为time毫秒。
        time毫秒后，会进入就绪状态。如果期间被打断，会出现检查性异常:InterruptException 
   
    void interrupt()
      打断阻塞状态下的线程对象。
      
    void join()
       将当前线程A加入到线程B中，线程B进入阻塞状态，直到线程A
       结束，线程B进入就绪状态，等待被分配时间片段。
        
    static void yield()
    线程对象让步的功能：让出时间片段，此线程进入就绪状态。
        
 十三、       
 同步锁：
   当多个线程操作临界资源时，可能会出现线程安全隐患问题。
   临界资源可能是：
  (1)某一个静态变量
  (2)某一个实例变量
  如果想解决这样的问题，需要使用同步操作。
  
   异步操作:多个线程同时开启，微观上断断续续，宏观上同时发生
                  断断续续：同一个方法内的两行代码不一定是两个挨着的时间片段
   同步操作:在并发的基础上，同一个方法内的两行代码执行时间片段
                  可以不挨着，但是其他线程不能对这两行代码的执行权 ，
                  保证了代码的原子性。即这两行代码是同步的，当前线程执行完后，
                  其他线程才有执行权。
  
想实现同步操作，提供了一个锁机制。
        我们将需要同步的代码加上一个内置锁对象，当某一个线程执行到此代码时，会获取锁对象，其他线程需要等待。当获取锁对象的线程执行完同步块(或者是因为异常)都会释放锁对象。其他线程通过cpu的线程调用才有机会获取锁对象的使用权。

     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方法等待的线程，
 natify():只会随机通知等待线程中的其中一个。
 notifyAll():通过所有等待的线程来竞争锁。
 
 

十四、
线程池：
   (1)如果每个任务都需要创建线程对象，内存开销大
   (2)方便管理线程对象。

线程池的原理: 就是一些线程的集合，线程的状态不是死亡状态，当线程池接收外面的任务时，线程池的管理器会查看是否有空闲线程，如果有，就会将任务分配给它，如果没有，任务处于等待队列中.

线程池的类型：ExecutorService
另外一个类Executors里提供了多个静态方法来获取线程池对象
       
    方法1：
    newSingleThreadExecutor()：
       获取单个线程的线程池对象，内部维护了一个无界队列用于存储任务 
  方法2:
    newFixedThreadPool(int nThreads) 
       创建一个固定数量线程的线程池，维护一个为无界队列
   方法3:
    newCachedThreadPool()
       创建一个可以根据需求来创建新线程的线程池对象，如果有可
       重用的，会优先使用。
   方法4:   
    newScheduledThreadPool(int corePoolSize)
       创建一个线程池，可以进行设置延迟或者是定时来执行任务        
        
        
生产者--消费者--仓库模式：此模式脱离了仓库没有任何意义。
(1)仓库用来存储数据。
(2)仓库不满的情况下，生产者可以生产
(3)仓库中满足消费者的需求时，消费者就可以消费