java线程、线程池，类、对象锁 java线程通信，线程的状态 wait/notify

线程创建的几种方法：

1. 继承Thread类创建线程类重写run方法
2. 实现Runnable接口重写run方法，拿到实例来作为Thread的target创建Thread类对象
3. 通过Callable和FutureTask创建线程

线程的状态：

1.新建状态：new Thread（r）;

2.就绪状态：还需和其他线程竞争CPU时间，才能进入运行状态； 原因：调用start（）方法，但不一定立即执行run（）方法；

3.运行状态：线程获得了cpu 时间片。 原因: 调用run（）方法。

4.阻塞状态：阻塞状态是指线程因为某种原因让出了cpu 时间片，暂时停止运行。 原因：① 通过调用Sleep()方法进入睡眠

5.死亡状态：①run方法正常结束导致线程死亡  ②.未捕获异常终止了run方法导致线程猝死；

可调用isAlive查看线程是否死亡，return true是出于运行或者阻塞状态， false是出于死亡状态；死亡线程不可复生;

线程池：

常见线程池:

newCachedThreadPool：无核心线程，可创建无限扩大的线程池；适用于负载较轻，用来执行短期异步任务;

newFixedThreadPool,: 创建固定大小的线程池，采用无界的阻塞队列；使用于负载较重；

newScheduledThreadPool:创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

newSingleThreadExecutor:采用延迟队列；适用于用于执行延时或者周期性任务。

常见的阻塞队列(分为有界和无界):

ArrayBlockingQueue
ArrayBlockingQueue是最典型的有界队列，其内部是用数组存储元素的，利用Reentrant实现线程安全

public ArrayBlockingQueue(int capacity) {
   this(capacity, false);
}
 
public ArrayBlockingQueue(int capacity, boolean fair) {
   if (capacity <= 0)
       throw new IllegalArgumentException();
   this.items = new Object[capacity];
   lock = new ReentrantLock(fair);
   notEmpty = lock.newCondition();
   notFull =  lock.newCondition();
}
 
我们在创建它的时候就需要指定它的容量，之后也不可以在扩容了，在构造函数中我们同样可以指定是否是公平的。如果ArrayBlockingQueue被设置为非公平的，那么就存在插队的可能；如果设置为公平的，那么等待了最长时间的线程会优先被处理，其它线程不允许插队。

LinkedBlockingQueue

其内部使用链表实现的，如果我们不指定它的初始容量，那么它的默认容量就为整形的最大值Integer.MAX_VALUE,由于这个数特别特别的大，所以它也被称为无界队列。

阻塞队列特点:

• 阻塞队列为空时，如果进行出队操作，会使当前线程阻塞，直到有新元素插入阻塞队列，该线程才被通知继续执行出队操作；
• 阻塞队列为满时，如果进行入队操作，会使当前线程阻塞，直到有元素出队时，该线程才会被通知继续执行入队操作。

为什么线程池一般要用阻塞队列:

由于阻塞队列的特点，它可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。
当队列中有任务时才唤醒对应线程从队列中取出消息进行执行，使得在线程不至于一直占用cpu资源。

线程池优点：

1.线程是稀缺资源，使用线程池可以重复利用线程，减少创建和销毁线程的次数。

2.可以根据系统的承受能力，动态调整线程池中的线程数量，防止消耗过多内存导致服务器崩溃

线程池的创建：

核心线程和普通线程的区别：核心线程空闲的时候不会被回收，非核心线程会被回收;

如何让核心线程销毁：allowCoreThreadTimeOut(true) ，线程池数量最后将销毁到0个。

一个task进入到线程池后的流程(核心线程和最大线程作用流程)：

1. 判断线程池里的核心线程是否都在执行任务，如果不是则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
2、线程池判断任务队列(一般是阻塞队列)是否已满，如果队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
3， 判断线程池里的非核心线程是否都处于 工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

 线程数量设置:  线程池设置多少合适_线程池大小设置多少合适-CSDN博客

饱和策略：

线程池中某个线程抛异常如何处理的?

ThreadPoolExecutor.execute 如果用户任务抛出了异常，在线程池运行的状态下，会重新创建一个worker线程。

这里就可能存在一个风险，即如果用户任务大量的抛出异常，可能会导出线程资源频繁的销毁、创建。因此，需要用户任务应当主动对异常进行处理，而不是消极的抛给线程池。

线程池执行任务: execute/submit

线程池execute方法(传参runnable): 无返回值，不知道执行结果

线程池submit方法(传参future)

ThreadPoolExecutor.submit 提交的用户任务，会包装成一个FutureTask，FutureTask执行用户任务，如果异常，不会对外抛出，仅是记录，但是在调用Future.get时，会抛出异常。

线程池的关闭

//threadPool.shutdown();

//threadPool.shutdownNow()；

（1）原理

可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池，它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。

（2）区别 shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表； shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。

（3）选择 只要调用了这两个关闭方法的其中一个，isShutdown方法就会返回true。当所有的任务都已关闭后,才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于我们应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown()来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow()来关闭线程池。

同步异步：

线程同步：发送一个指令，需要等待返回结果，才能发出下一个指令，需要等待；

线程异步：发送一个指令，不需要等待，即可直接发出下一个指令；

一般情况下，都采用异步，效率更高；但是比如说银行系统，必须采用同步，这样才能保证数据的共享和安全性；

synchronize关键字：

每个 synchronized 方法都必须获得调用该方法的类实例的锁（或者类锁）方能执行，否则所属线程阻塞；直到synchronize方法结束后，才会释放锁；所有声明synchronize的方法中只有一个在调用；避免了类中的成员变量的访问冲突；

记住：只要锁的是不同的锁，就会导致无法同步；怎样才是不同的锁呢？

4.同步方法块的括号里是类名.class，锁就是当前类的class 对象

1.一个类的类锁就只有一个，所以一个类的锁都是相同的

2.一个类中的对象锁有很多个，一个类的对象锁互不相同；

3.类锁和对象锁互不相同；

对象锁：

 对象锁举例：

 

类锁（下面两种实现方法）：

由于用的是同一个类锁，锁住的东西是相同的，所以有下面的结果

但如果一个锁住的是类，一个锁住的是对象的话，如下：

操作的是不同的锁，所以会有下面的结果：

下面一个例子采用了同步锁，来对实例方法进行同步，即构造两个线程，往其中都加入一个含有同步实例方法的对象

（Android中创建子线程来写耗时逻辑）单线程的暂停和开始可以在线程中放入一个flag，通过这个flag来对线程进行控制。

多线程暂停和开始 ：

  暂停用interrupt（其实也可以用flag控制）不用已淘汰的stop，注意interrupt只是判断线程是否暂停，在线程的run方法中抛出异常（一定要调用一下interrupt方法，才能进行interrupt判断） 或者用break但是（在for循环中  break之后for还是会接着执行），所以尽量用interrupt       

  恢复就是相对暂停来写逻辑，和上述一样

sleep和wait方法的区别是，sleep不会放弃对象的监视器，wait会放弃对象的监视器

线程沉睡和唤醒用wait和notify方法。（都在synchronize中使用，而synchronize一般都是在线程中的某个方法用的，因为为了同步线程，所以是一个Thread对象创建出多个threadA，B...引用 来调用这个线程方法）

注意线程的上述方法和Object自带的wait()和notifyAll()方法的区别，wait()和notifyAll()一定要在synchronize同步语句中添加，因为调用这两个方法一定要获得对象锁，synchronize块就是为了获取锁，有synchronize块的线程处于运行状态，没有它的线程则处于阻塞状态；

调用wait时，会将对象锁放弃；之后其他线程均分机会来获取这个锁

如何正确的控制线程的停止和回复：

private class MyThread extends Thread {
    private final Object lock = new Object();
    private volatile boolean pause = false;

    /**
     * 调用这个方法实现暂停线程
     */
    void pauseThread() {
        pause = true;
    }

    /**
     * 调用这个方法实现恢复线程的运行
     */
    void resumeThread() {
        pause = false;
        synchronized (lock) {
            lock.notifyAll();
        }
    }

    /**
     * 注意：这个方法只能在run方法里调用，不然会阻塞主线程，导致页面无响应
     */
    void onPause() {
        synchronized (lock) {
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        super.run();
        try {
            int index = 0;
            while (true) {
                // 让线程处于暂停等待状态
                while (pause) {
                    onPause();
                }
                try {
                    System.out.println(index);
                    Thread.sleep(50);
                    ++index;
                } catch (InterruptedException e) {
                    //捕获到异常之后，执行break跳出循环
                    break;
                }
            }
        } catch (NullPointerException e) {
            e.printStackTrace();
        }
    }
}

暂停的话，只需执行：

pauseThread();

恢复线程运行：

resumeThread();

resumeThread();