java ionio thread

java多态

封装，继承，多态是java的三大特性；

Java实现多态有三个必要条件：继承、重写、向上转型。

多态的实现：继承和借口；
继承是实现多态的方式之一；

NIO

总的来说java 中的IO 和NIO的区别主要有3点：

IO是面向流的，NIO是面向缓冲的；
IO是阻塞的，NIO是非阻塞的；
IO是单线程的，NIO 是通过选择器来模拟多线程的；

一般来说 I/O 模型可以分为：同步阻塞，同步非阻塞，异步阻塞，异步非阻塞 四种IO模型。

同步阻塞 IO ：

在此种方式下，用户进程在发起一个 IO 操作以后，必须等待 IO 操作的完成，只有当真正完成了 IO 操作以后，用户进程才能运行。 JAVA传统的 IO 模型属于此种方式！

同步非阻塞 IO:

在此种方式下，用户进程发起一个 IO 操作以后可以返回做其它事情，但是用户进程需要时不时的询问 IO 操作是否就绪，这就要求用户进程不停的去询问，从而引入不必要的 CPU 资源浪费。其中目前 JAVA 的 NIO 就属于同步非阻塞 IO 。

异步阻塞 IO ：

此种方式下是指应用发起一个 IO 操作以后，不等待内核 IO 操作的完成，等内核完成 IO 操作以后会通知应用程序，这其实就是同步和异步最关键的区别，同步必须等待或者主动的去询问 IO 是否完成，那么为什么说是阻塞的呢？因为此时是通过 select 系统调用来完成的，而 select 函数本身的实现方式是阻塞的，而采用 select 函数有个好处就是它可以同时监听多个文件句柄，从而提高系统的并发性！

异步非阻塞 IO:

在此种模式下，用户进程只需要发起一个 IO 操作然后立即返回，等 IO 操作真正的完成以后，应用程序会得到 IO 操作完成的通知，此时用户进程只需要对数据进行处理就好了，不需要进行实际的 IO 读写操作，因为 真正的 IO读取或者写入操作已经由 内核完成了。目前 Java 中还没有支持此种 IO 模型。

java传统的io是基于同步阻塞的io模型；

锁

锁的分类

公平锁/非公平锁
可重入锁
独享锁/共享锁
互斥锁/读写锁
乐观锁/悲观锁
分段锁
偏向锁/轻量级锁/重量级锁
自旋锁

IO密集型应用适合多线程，因为io操作大多会阻塞线程，cpu利用率低，可以多开线程； Runnable比Thread优势是java不能多继承，所以线程类不能再继承其他类； synchronized 不是公平锁，多线程尝试获取，谁抢到是谁的；

暂停线程 suspend
放弃cpu资源 yield方法
线程具有优先级，可以通过方法设置线程优先级，cpu会将资源尽量给优先级高的线程，但是当优先级差别不大的时候，优先级高的不一定先执行完run方法
线程有两种，一种用户线程，一种守护线程，直到用户线程都销毁，守护线程才销毁
消息同步
wait和notify必须是在同步方法和同步代码块里面调用，要不然会抛出异常
notify方法是继承自Object类，可以唤醒在此对象监视器等待的线程，也就是说唤醒的是同一个锁的线程
notify方法调用之后，不会马上释放锁，而是运行完该同步方法或者是运行完该同步代码块的代码
调用notify后随机唤醒的是一个线程
调用wait方法后会将锁释放
wait状态下中断线程会抛出异常
wait(long),超过设置的时间后会自动唤醒，还没超过该时间也可以通过其他线程唤醒
notifyAll可以唤醒同一锁的所有线程
如果线程还没有处于等待状态，其他线程进行唤醒，那么不会起作用，此时会打乱程序的正常逻辑
ThreadLocal

ReentrantLock 重入锁

public class MyService {

    private Lock lock = new ReentrantLock();
    private Condition condition=lock.newCondition();
    public void testMethod() {
        
        try {
            lock.lock();
            System.out.println("开始wait");
            condition.await();
            for (int i = 0; i < 5; i++) {
                System.out.println("ThreadName=" + Thread.currentThread().getName()
                        + (" " + (i + 1)));
            }
        } catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }
}

通过创建Condition对象来使线程wait，必须先执行lock.lock方法获得锁

public void signal()
    {
        try
        {
            lock.lock();
            condition.signal();
        }
        finally
        {
            lock.unlock();
        }
    }

condition对象的signal方法可以唤醒wait线程

Lock lock=new ReentrantLock(true);//公平锁
Lock lock=new ReentrantLock(false);//非公平锁

公平锁指的是线程获取锁的顺序是按照加锁顺序来的，而非公平锁指的是抢锁机制，先lock的线程不一定先获得锁。

Lock类有读锁和写锁，读读共享，写写互斥，读写互斥

synchronized

synchronized关键字是通过字节码指令来实现的
synchronized关键字编译后会在同步块前后形成monitorenter和monitorexit两个字节码指令

volatile

volatile boolean status = false;
一个轻量级的同步锁机制；
volatile禁止重排序；

保证变量对所有的线程的可见性，当一个线程修改了这个变量的值，其他线程可以立即知道这个新值（之所以有可见性的问题，是因为java的内存模型）

所有变量都存在主内存，每条线程有自己的工作内存，工作内存保存了被该线程使用的变量的主内存副本拷贝
线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，也就是必须先通过工作内存
一个线程不能访问另一个线程的工作内存

Atomic

AtomicBoolean , AtomicInteger, AtomicLong, AtomicReference
当有多个线程同时对单个（包括基本类型及引用类型）变量进行操作时，具有排他性，即当多个线程同时对该变量的值进行更新时，仅有一个线程能成功，而未成功的线程可以像自旋锁一样，继续尝试，一直等到执行成功。
其原理：CAS操作（compare and swap 对比和设置），是通过一个cpu指令实现的，这个指令是一个原子指令，指令有3个操作数ABC，A为内存位置，B为预期值，C为新值，那么用V更新A的值，如果A符合旧预期值B，如果不符合就不更新，这个过程是原子操作
所以我们并没有通过代码来实现同步，而是通过硬件级别的cpu指令来实现的，并不像synchronized一样阻塞线程

http://www.cnblogs.com/-new/p/7358255.html

线程池

新任务创建线程与否逻辑
核心线程池是否已满–> 队列是否已满–> 线程池是否已满
ThreadPoolExecutor

配置线程池：
cpu密集型和io密集型线程数的选择，cpu密集型不需要太多的线程，可以充分利用cpu资源，io密集型适当多线程，io阻塞时可以切换至另一线程。
优先级不同的的任务可以使用PriorityBlockingQueue来处理
建议使用有界队列，能够增加系统的稳定性（如果使用无界队列，当出现问题时候，队列无限增长，此时可能会占用大量内存，导致系统出现问题）和预警能力（当出现队列占满的时候，抛出异常，可以让开发人员及时发现）

CompletionService 可以实现在单线程中将下游任务多线程话