Java 线程

    当一个程序进入内存运行即变成一个进程，进程是处于运行过程中的程序。进程是系统进行资源分配和调度的基本单位，进程切换开销比较大。
    进程包含三大特征
1.独立性:系统中独立存在的实体，它可以拥有自己独立的资源，私有的地址空间;
2.动态性:具有自己的生命周期和各种不同的状态，这些状态在程序中是不具备的;
3.并发性:单个处理器并发执行多个进程，进程之间，不会互相影响。

    对于一个CPU而言，它在某个时间点上只能执行一个程序，就是说只能运行一个进程。CPU不断在这些进程之间轮回切换，CPU的执行速度相对于我们的感觉太快，我们感觉不到，所以CPU在多个进程之间轮回执行，但我们感觉好像多个进程同时执行。
    线程被称为轻量级的进程，线程是进程的执行单元，就像进程在操作系统中的地位一样。线程在程序中是独立的，并发的执行流。当进程被初始化后，主线程就被创建了，对一般的应用程序来说，通常仅要求有一个主线程，但我们也可以在该进程内创建多条顺序执行流，这些顺序执行流就是线程，每条线程是相互独立的。
    线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性，多个线程将共享同一个进程的虚拟空间，线程共享的环境包括进程代码段，进程的公有数据等，利用这些共享的数据，线程很容易实现相互之间的通信。当操作系统创建一个进程时，该进程必须分配独立的内存空间，分配大量相关资源，但创建一个线程简单的多，因此使用多线程来实现并发比使用多进程来实现并发的性能要高得多。

多线程的优点
1，进程之间不能共享内存，但线程之间共享内存非常容易；
2，系统创建进程需要为该进程重新分配系统资源，但创建线程不用，从而效率提高；
3，Java语言中内置多线程功能的支持，简化了Java的多线程编程。

Thread类和Runable接口创建线程的对比
继承Thread类方式的多线程的优点：
编写简单，如果访问当前线程，无需使用Thread.currentThread方法，直接使用this即可获得当前线程。
继承Thread类方式的多线程缺点：
因为线程已经继承了Thread类，所以不能再继承其他的类。

实现Runable接口的优点：
线程只是实现了Runable接口，还可以继承其他的类，在这种方式下，可以多个线程共享同一个目标(target)对象，所以非常适合多个线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，体现了面向对象的思想。
实现Runable接口的缺点：
编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread方法。
    有一种线程它是在后台运行的，它的任务是为其他线程提供服务，这种线程称为后台线程，又称为守护线程，又称为精灵线程。JVM的垃圾回收线程就是典型的后台线程。后台线程有个特征：如果所有的前台线程都死亡，后台线程会自动死亡。

实现同步机制有两个方法：
1.同步代码块：
synchronized(同一个数据){}    同一个数据：就是N条线程同时访问一个数据
2.同步方法：
public synchronized 数据返回类型 方法名(){}
就是使用 synchronized 来修饰某个方法，则该方法称为同步方法。对于同步方法而言，无需显示指定同步监视器，同步方法的同步监视器是 this 也就是该对象的本身，通过使用同步方法，可非常方便的将某类变成线程安全的类，具有如下特征：
1，该类的对象可以被多个线程安全的访问。
2，每个线程调用该对象的任意方法之后，都将得到正确的结果。
3，每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。
注：synchronized关键字可以修饰方法，也可以修饰代码块，但不能修饰构造器，属性等。

实现同步机制注意以下几点:安全性高，性能低，在多线程用。性能高，安全性低，在单线程用。
1，不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源方法的进行同步;
2，如果可变类有两种运行环境，当线程环境和多线程环境则应该为该可变类提供两种版本：线程安全版本和线程不安全版本(没有同步方法和同步块)。在单线程中环境中，使用线程不安全版本以保证性能，在多线程中使用线程安全版本.

Java.lang.object 里的三个方法wait() notify()  notifyAll()
wait方法导致当前线程等待，直到其他线程调用同步监视器的notify方法或notifyAll方法来唤醒该线程;
wait(mills)方法
都是等待指定时间后自动苏醒，调用wait方法的当前线程会释放该同步监视器的锁定，可以不用notify或notifyAll方法把它唤醒;
notify()方法唤醒在同步监视器上等待的单个线程，如果所有线程都在同步监视器上等待，则会选择唤醒其中一个线程，选择是任意性的，只有当前线程放弃对该同步监视器的锁定后，也就是使用wait方法后，才可以执行被唤醒的线程;
notifyAll()方法唤醒在同步监视器上等待的所有的线程。只用当前线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程。
    Java线程分守护线程和用户线程，由创建时设置。在Java中，线程的调度是基于时间片基础上的优先级优先原则 。抢占式调度模型(优先级优先)是指可能有多个线程是可运行的，但只有一个线程在实际运行。这个线程会一直运行，直至它不再是可运行的(运行时间到，时间片原则，或者，另一个具有更高优先级的线程抢占，优先级优先原则)。对于后面一种情形，低优先级线程被高优先级线程抢占了运行的机会。
    因为 Java 线程是抢占式的，所以你必须确保你的代码中的线程会不时地给其它线程运行的机会。这可以通过在各种时间间隔中发出 sleep()调用来做到。线程可以调用另外一个线程的 interrupt()方法，这将向暂停的线程发出一个InterruptedException。Thread 类的 sleep()方法对当前线程操作，因此被称作 Thread.sleep(x),它是一个静态方法。sleep()的参数指定以毫秒为单位的线程最小休眠时间。

    一个线程可能因为各种原因而不再是可运行的:
  1.该线程调用Thread.sleep() 进入中断状态必须经过规定的毫秒数才能从中断状态进入可运行状态
  2.该线程进行了 IO操作 而进入中断状态必须等待IO操作完成，才能 进入可运行状态
  3.该线程调用了其它线程的 join()方法，而使自己进入中断状态必须等待调用的线程执行完，才能进入可运行状态 
  4.该线程试图访问被另一个线程锁住的对象 而进入中断状态必须等待另一个线程释放对象锁，该线程才能进入可运行状态.该线程调用 wait()方法而进入中断状态必须通过其他线程调用notify()或者notifyAll()方法才能进入可运行状态 
     
    终止一个线程:当一个线程结束运行并终止时，它就不能再运行了。可以用一个标志来指示 run()方法，必须退出一个线程。
    线程的优先级:使用getPriority方法测定线程的当前优先级。使用 setPriority方法设定线程的当前优先级。线程优先级是一个整数（1 到 10）。Thread类包含下列常数：
Thread.MIN_PRIORITY      1       （最低级别）
Thread.NORM_PRIORITY     5       （默认的级别）
Thread.MAX_PRIORITY      10      （最高级别）
    延迟线程:sleep()方法是使线程停止一段时间的方法。在 sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非
(a)"醒来"的线程具有更高的优先级
(b)正在运行的线程因为其它原因而阻塞
    线程同步:为了保证共享数据在任何线程使用它完成某一特定任务之前是一致的， Java使用关键字
synchronized，允许程序员控制共享数据的线程。
    对象锁:在 Java技术中，每个对象都有一个和它相关联的标志。这个标志可以被认为是"锁标志
"。 synchronized关键字使线程能和这个标志交互，即允许独占地存取对象。当线程运行到 synchronized语句，它检查作为参数传递的对象，并在继续执行之前试图从对象获得锁标志。持有锁标志的线程执行到 synchronized()代码块末尾时将释放锁。即使出现中断或异常而使得执行流跳出 synchronized()代码块，锁也会自动返回。此外，如果一个线程对同一个对象两次发出 synchronized调用，则在跳出最外层的块时，标志会正确地释放，而最内层的将被忽略。
    对于非static的情况，sysnchronized是对象级别的，谁拿到这个锁，谁就可运行obj控制的那段代码。如果方法用static修饰，synchronized的作用范围就是class一级的，它对类的所有对象起作用。
public synchronized void fun()
{}
等同于：
public void fun()
{
    synchronized(this) {
    } 
}
    死锁:当一个线程等待由另一个线程持有的锁，而后者正在等待已被第一个线程持有的锁时，就会发生死锁.避免死锁的一个通用的经验法则是：决定获取锁的次序并始终遵照这个次序。按照与获取相反的次序释放锁。
    Object 类中提供了用于线程通信的方法：wait()和 notify()，notifyAll()。如果线程对一个指定的对象 x 发出一个 wait()调用，该线程会暂停执行,此外，调用 wait()的线程自动释放对象的锁，直到另一个线程对同一个指定的对象x 发出一个 notify()调用。 为了让线程对一个对象调用wait()或 notify()，线程必须锁定那个特定的对象。也就是说，只能在它们被调用的实例的同步块内使用wait()和 notify()。
    互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
    同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。