实战java高并发程序设计第之java并发基础

进程与线程

进程：进程是计算机中程序关于某次数据集合上的一次运行活动，是体统进行分配和资源调度的基本单位，是操作系统的基础，进程是线程的容器。当然进程也可以创建多个线程。
自我理解：进程是一种容器，比如在一个房间里，有爸爸妈妈我三个线程，当爸爸在家的时候，他想干什么就干什么（有地位的话），但是我和爸爸在家的话，我看动画片，爸爸就不能看体育，也就是两个线程争夺资源，当然大部分的时候三个线程相互协作，我写作业，爸爸挣钱养家，妈妈做家务。保证了进程的整体的安全。
线程的状态

线程的所以状态在Thread中的State是枚举定义的

public enum State{
 NEW,
 RUNNABLE,
 BLOCKED,
 WAITING,
 TIMED_WAITING,
 TERMINATED;
}

初始线程

第一种方法：

Thread thread = new Thread();
thread.start();

线程在调用了start方法之后,start就会新建一个线程放这个线程执行run方法，但是若调用的run方法的话，那么只会在当前线程中串行的执行run（）中的代码，同时run方法是需要我们自己重写的，不然他什么都干不了

第二种方法:

public class CreateThread implements Runnable{
     public static void mian(String[] args){
          Thread thread = new Thread(new CreateThread());
          thread.start();
     }
}

实现Runnable接口，并且将实例传入Thread，这样可以避免重载run方法。
第三种：

实现实现Callable接口重写call方法
第四章:

线程池创建

终止线程

线程一般运行完就会自动关闭，但是有时候一些服务端的线程可能会常驻系统，这时候可以用Thread的stop去关闭，但是stop是暴力关闭（并且释放改对象所持有的锁)，比如某个线程执行到一半就强行关闭，那么可能导致数据不一致的,所以当我们想要关闭一个线程的时候，我们自行决定线程何时退出就行。

线程中断

线程中断并不会让线程立马退出，而是给线程发送一个通知，告知目标线程，希望你退出，是否退出完全由线程自己去处理，若中断后，线程无条件退出，那就和直接调用stop方法一样，会产生很多的问题。

public void Thread.interrupt();//中断线程
public boolean Thread.isInterrupt();//判断是否被中断
public static boolean Thread.interrupted();//判断是否被中断，并且清除当前的中断状态

下面的代码就进行的中断操作，如果没有if判断，那么虽然给了thread进行了中断，但是thread并没有处理中断的逻辑，所以thread线程也仅仅是被置于中断状态，但是这个中断没有任何作用。

加了if了的话，可以判断当前线程是不是处于中断状态，如果是，那么退出while循环，结束线程。一般出现wait()和sleep()这样的操作，只能同中断来识别。

public class interruptThread {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(){
            public void run(){
                while(true){
                    if(Thread.currentThread().isInterrupted()){
                        System.out.println("interrupt");
                        break;
                    }
                    Thread.yield();
                }
            }
        };
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}

线程wait()/等待和notify()/通知

这两个是Obejct类中的方法，也就是说什么对象都可以调用这两个方法。

public final void wait() throws InterruptedException
public final native void notify()

当一个对象实例被调用了wait的方法后,当前线程就会这个对象等待，比如：线程A调用了obj.wait（）方法，那么线程A就停止执行，转为等待状态，当线程A等到其他的线程出现调用obj.notify（）方法为止，这个时候，obj对象就成为多个线程的通信手段。
notify()方法是从等待队列中随机唤醒一个线程，完全随机选择。但是notifyAll()方法就是把等待队列的所以线程都唤醒。

此外Object.wait()方法必须在对应的synchronized语句中。

public class PublicThreadWN {
    final static Object obj = new Object();
    public static class T1 extends Thread{
        public void run(){
            synchronized(obj){
                System.out.println(System.currentTimeMillis()+":T1 start!");
                try{
                    System.out.println(System.currentTimeMillis()+"T1 wait for obj");
                    obj.wait();
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis()+":T1 is end");
            }
        }
    }
    public static class T2 extends Thread{
        public void run(){
            synchronized(obj){
                System.out.println(System.currentTimeMillis()+":T2 is start");
                obj.notify();
                System.out.println(System.currentTimeMillis()+":T2 end");
                try{
                    Thread.sleep(2000);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) {
        Thread t1 = new T1();
        Thread t2 = new T2();
        t1.start();
        t2.start();
    }

}

输出结果为：

1506662910562:T1 start!
1506662910562T1 wait for obj
1506662910562:T2 is start
1506662910562:T2 end
1506662912562:T1 is end
为什么会这样呢，开启了两个线程T1和T2，T1执行了wait方法，在T1执行这个方法前，先获取了obj的对象锁，wait执行完，T1开始等待，同时释放obj的锁，T2在执行notify()方法前，也会先获得obj对象锁，之后T1在得到notify()的通知后，还是会先尝试着重写获得obj的对象锁，可以看见在T2执行完之后2秒后，T1才执行end。
wait和sleep的区别?

Object.wait和Thread.sleep方法都可以让程序等待若干时间，但是wait可以被唤醒，而且wait会释放目标对象的锁，但是Thread.sleep()缺少不会释放目标对象的锁。
sleep之所以被try-catch包裹是因为如果程序在sleep方法执行后，当前线程会休眠一段时间，会抛出InterruptedException，它不是一个运行时异常，所以必须得处理。

线程的挂起(suspend)和继续执行(resume)

suspend和resume是两个看起来很有用的方法，但是不推荐使用，而且已经作废的方法，suspend()在导致线程暂停的时候，并不会让线程释放任何锁资源，所以，其他的线程想要访问它被它占用的方法锁时，都会被牵连，导致无法正常运转。知道在对应的线程上运行了resume()操作，被挂起的线程才能继续，从而所有相关锁上的线程也可以继续执行，但是resume()操作意外的在suspend()之前执行了，那么挂起的线程就很难有机会被继续执行，而且占用的锁也得不到释放了，导致整个系统工作不正常，同时被挂起的线程，从状态上来看，居然是Runnable。

等待线程结束(join)和谦让(yield)

public final void join() throws InterruptedException
public final synchronized void join(long mills) throws InterrupredException

第一个join表示无线等待，一直阻塞当前线程，直到目标线程执行完毕。
第二个join方法给了一个最大的等待时间，如果超过时间线程还在运行，当前线程就会因为等不及而继续向下开始执行。
join方法的作用是，调用join方法的线程先执行完，其他线程再操作，也就是变并行为串行。

Thread.yield();
public static void yield();

改方法一单执行，那么就会让当前线程让出CPU，让出CPU不表示当前线程不执行了，当前线程再让出CPU之后，还会进行CPU资源抢夺，但是能否够再次被分配到，就不一定了。
理解起来也就是，Thread.yield的 调用完成了自己的一些工作，他就可以休息一下，给其他一些线程一些工作机会。一般用于优先级非常低和不重要的线程，减少CPU占用资源。

volatile

volatile的作用就是保持这个变量的可见性。最新值。易修改的
volatile可以保证数据的可见性和有序性。
volatile不能代替锁的一个原因就是，volatile对复合操作的原子性无法保证，比如i++

守护线程

守护线程是一种特殊的线程，系统的守护者，在后台默默地完成一些系统性的服务，比如垃圾回收线程，当一个java应用只有守护线程的时候，java虚拟机就自动退出了。
设置守护线程需要在start()之前设置，不然会出现异常（可以正常执行，但是该线程会被当做用户线程去执行）

线程优先级

java线程优先级有1到10个等级，内部有三个内置静态标量表示

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public fianl static int MAX_PRIORITY = 10;

数字越大，优先级越高，高优先级的一般比低优先级的完成的更快。

synchronized

指定加锁的对象：对对象加锁，进入同步代码块前要获得给定对象的锁。
直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。
直接作用于静态方法：相当于当当前类加锁，进入同步代码前要获得当前类的锁。