java高并发中重要的概念

1.专业术语解释

同步(synchronous)与异步(asynchronous):

1. 同步: 就是发出一个功能调用时，在没有得到结果之前，该调用就不返回或继续执行后续操作。
   例如：B/S模式中的表单提交 ，提交请求->等待服务器处理->处理完返回 这个期间客户端浏览器不能干任何事
2. 异步：当一个异步过程调用发出后，调用者在没有得到结果之前，就可以继续执行后续操作。当这个调用完成后，一般通过状态、通知和回调来通知调用者。对于异步调用，调用的返回并不受调用者控制。
   例如：B/S模式中的ajax请求，具体过程是：客户端发出ajax请求->服务端处理->处理完毕执行客户端回调，在客户端（浏览器）发出请求后，仍然可以做其他的事。
3. java中实现同步异步的方式：
   1.ThreadLocal:
   保证不同线程拥有不同实例，相同线程一定拥有相同的实例，即为每一个使用该变量的线程提供一个该变量值的副本，每一个线程都可以独立改变自己的副本，而不是与其它线程的副本冲突。
   2. volatile:
      修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。
   3. synchronized方法：
      当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
   4. wait方法与notify配合使用：
      1.wait与notify:
      都是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
   5. 以下代码就是通过wait与notify解决生产者与消费者问题

public class ProducerConsumerInJava {
    public static void main(String args[]) {
        Queue buffer = new LinkedList();
        int maxSize = 10;
        Thread producer = new Producer(buffer, maxSize, "生产者");
        Thread consumer = new Consumer(buffer, maxSize, "消费者");
        producer.start();
        consumer.start();
    }
}

class Producer extends Thread {
    private Queue<Integer> queue;
    private int maxSize;

    public Producer(Queue<Integer> queue, int maxSize, String name) {
        super(name);
        this.queue = queue;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.size() == maxSize) {
                    try {
                        System.out.println("队列满了,生产者线程等待消费者从队列中消费");
                        queue.wait();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                Random random = new Random();
                int i = random.nextInt();
                System.out.println("生产产品 : " + i);
                queue.add(i);
                queue.notifyAll();
            }
        }
    }
}

class Consumer extends Thread {
    private Queue<Integer> queue;
    private int maxSize;

    public Consumer(Queue<Integer> queue, int maxSize, String name) {
        super(name);
        this.queue = queue;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    System.out.println("队列空了,消费者等待生产者生产产品放入队列");
                    try {
                        queue.wait();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                System.out.println("从队列中消费产品 : " + queue.remove());
                queue.notifyAll();
            }
        }
    }
}

并发(concurrency)与并行(parallelism):

1. 并发:是指两个或多个事件在同一时间间隔发生。
2. 并行: 是指两个或者多个事件在 同一时刻发生
3. 例如：单个cpu只能在同一时间间隔处理一个进程
   而多个cpu则可以同一时刻处理多个线程

临界区:

临界区表示一种公共资源或者是共享数据，可以被多线程使用，但是每次只能有一个线程使用它，一旦临界区资源被占用，其他线程想要使用，就必须等待那个占有线程退出临界区。

阻塞(blocking)与非阻塞(non-blocking)：

1. 阻塞与非阻塞通常用来形容多线程间的相互影响，比如一个线程占用了临界区资源，那么其他所有需要这个资源的线程就在这个临界区中等待，等待会导致线程挂起，这种情况是阻塞的。
2. 非阻塞：允许多个线程同时进入临界区。

死锁(dealock)：

1. 集合中的每一个进程都在等待只能由本集合中的其他进程才能引发的事件，那么该组进程是死锁的
2. 例如程序中两个或多个线程发生永久堵塞（等待），每个线程都在等待被其他线程占用并堵塞了的资源。例如，如果线程A锁住了对象1并等待对象2，而线程B锁住了对象2并等待对象1，这样两个线程就发生了死锁现象。

public class DeadLock {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    public static void main(String[] args){
        Thread a = new Thread(new Lock1());
        Thread b = new Thread(new Lock2());
        a.start();
        b.start();
    }    
}
class Lock1 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock1 running");
            while(true){
                synchronized(DeadLock.obj1){
                    System.out.println("Lock1 lock obj1");
                    Thread.sleep(3000);//获取obj1后先等一会儿，让Lock2有足够的时间锁住obj2
                    synchronized(DeadLock.obj2){
                        System.out.println("Lock1 lock obj2");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
class Lock2 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock2 running");
            while(true){
                synchronized(DeadLock.obj2){
                    System.out.println("Lock2 lock obj2");
                    Thread.sleep(3000);
                    synchronized(DeadLock.obj1){
                        System.out.println("Lock2 lock obj1");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

饥饿(starvation):

1. 一个线程因为CPU时间全部被其他线程抢走而得不到CPU运行时间，这种状态被称之为“饥饿”。

活锁(livelock)：

• 指的是任务或者执行者没有被阻塞，由于某些条件没有满足，导致一直重复尝试—失败—尝试—失败的过程。处于活锁的实体是在不断的改变状态，活锁有可能自行解开。