JAVA高并发实战——Java并行程序基础

一、线程与进程的区别

• 线程就是轻量级的进程，是程序执行的最小单位。使用多线程而不是用多进程去进行并发程序的设计，是因为线程间的切换和调度的成本远远小于进程。

• 线程的生命周期

  
  
  在这里插入图片描述
  
  

  1、NEW状态：刚刚创建线程，线程还没开始执行。调用start（），线程开始执行
  2、RUNNABLE状态：表示线程所需的一切资源已经准备好了。
  3、BLOCKED状态：如果线程在执行过程中遇到了synchronized同步块，就会进入 BOLCKED阻塞状态，这时线程会暂停执行，直到获得请求的锁
  4、WAITING状态：进入一个无时间限制的等待。WAINTING和TIMED_WAITING的线程一般是在等待一些特殊的事件，比如wait（）方法等待的线程等待notify（）方法，而通过join（）方法等待的线程则会等待目标线程的终止。
  5、TIMED_WAITING状态:会进入一个有时限的等待。
  6、RUNNABLE状态：等到了期望的时间，线程会继续执行，进入RUNNABLE状态
  7、TERMINATED状态：结束。
  ==注意：从NEW状态出发后，线程不能再回到NEW状态，同理，对于TERMINATED状态的线程也不能再回到RUNNABLE状态。==

二、线程的基本操作

• 新建线程
  1、重写Thread的run（）方法

public class Test01 {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                System.out.println("Hello");
            }
        };
        t1.start();
    }
}

         2、实现Runnable接口（更为合理）

public class Test02 implements Runnable {

    public static void main(String[] args) {
        Thread t1 = new Thread(new Test02());
        t1.start();
    }

    @Override
    public void run() {
        System.out.println("Oh, I am Runnable");
    }
}

• 终止线程
  不要使用stop（）方法直接终止线程，并且这个方法已经废弃。
  Thread.stop()方法会直接终止线程，并立即释放这个线程所持有的锁，无法保证对象的一致性
  正确的终止方法：（设置一个标志变量stopme）

 public static class ChangeObjectThread extends Thread {
        volatile boolean stopme = false;

        public void stopMe() {
            stopme = true;
        }

        @Override
        public void run() {
           while(true) {
               if(stopme) {
                   System.out.println("exit by stop me");
                   break;
               }

               synchronized (u) {
                   int v = (int)(System.currentTimeMillis() / 1000);
                   u.setId(v);
                   //do something
                   try {
                       Thread.sleep(100);
                   }catch (InterruptedException e) {
                       e.printStackTrace();
                   }

                   u.setName(String.valueOf(v));
               }
               Thread.yield();
           }
        }
    }

• 线程中断
  线程中断是一种重要的线程协作机制。线程中断并不会使线程立即退出，而是给线程发送一个通知，通知目标线程，有人希望你退出啦。至于目标线程接到通知后如何处理，则完全由目标线程自行决定。
  有三个方法和线程中断有关：

  
  
  在这里插入图片描述
  
  

  判断线程中断并处理完事情后退出的正确方法：

public class Test04 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                while(true) {
                    if(Thread.currentThread().isInterrupted()) {
                        System.out.println("Interrupted");
                        break;
                    }
                    try {
                        Thread.sleep(2000);
                    }catch (InterruptedException e) {
                        System.out.println("Interrupted when sleep");
                        Thread.currentThread().interrupt();
                    }
                    Thread.yield();
                }
            }
        };
        t1.start();
        Thread.sleep(1000);
        t1.interrupt();
    }
}

注意：Thread.sleep()方法由于中断而抛出异常，此时，它会清楚中断标记，如果不加处理，那么下一次循坏开始时，就无话捕获这个中断，故在异常处理中，再次设置中断标志位。

• 等待（wait）和通知（notify）
  1、JDK提供了两个非常重要的接口线程：等待wait（）方法和通知notify（）方法。这两个恶方法并不是在Thread类中的，而是在Object类。意味着所有对象都可以调用这两个方法。
  2、工作实现：比如，在线程A中，调用了obj.wait()方法，那么线程A就会停止继续执行，转为等待状态。等待到何时结束呢？线程A会一直等到其他线程调用了obj.notify()方法为止。
  3、工作原理：如果一个线程调用了obj.wait()方法，那么它就会进入object对象的等待队列。这个等待队列中，可能会有多线程，因为系统运行多个线程同时等待某一个对象。当object.notify()方法被调用时，它就会从这个等待队列中随机选择一个线程，并将其唤醒。需要注意的是，这个选择是不公平的，是随机唤醒某一个线程。

  
  
  在这里插入图片描述
  
  

  4、Object对象还有一个类似的notifyAll()方法，它会唤醒等待队列中所有的线程。
  5、这里举出一个简单的案例：

public class SimpleWN {
    final static Object object = new Object();

    public static class T1 extends Thread {
        public void run() {
            synchronized (object) {
                System.out.println(System.currentTimeMillis() + ":T1 start!");
                try {
                    System.out.println(System.currentTimeMillis() + ":T1 wait for object");
                    object.wait();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + ":T1 ends");
            }
        }
    }

    public static class T2 extends Thread {
        public void run() {
            synchronized (object) {
                System.out.println(System.currentTimeMillis() + ":T2 start!notify one thread");
                object.notify();
                System.out.println(System.currentTimeMillis() + ":T2 ends");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {

                }
            }
        }
    }

    public static void main(String[] args) {
        Thread t1 = new T1();
        Thread t2 = new T2();
        t1.start();
        t2.start();
    }
}

在这里插入图片描述

注意：Object.wait()方法和Thread.sleep()方法都可以让线程等待若干时间。除wait（）方法可以被唤醒外。另外一个主要区别就是wait（）方法会释放目标对象的锁、而Thread.sleep()方法不会释放任何资源。

• 等待线程结束（join）和谦让（yield）
  join（）方法：第一个join（）方法表示无限等待，它会一直阻塞当前线程，直到目标线程执行完毕。第二个方法给出一个最大等待时间，如果超过给定时间目标线程还在执行，当前线程就不再等了，继续往下执行。

  
  
  在这里插入图片描述
  
  

  yield()方法：yield方法会使当前线程主动让出CPU。但是要注意，让出CPU后，还是会进行CPU资源的争夺。如果你觉得一个线程不那么重要，或者优先级非常低，而且又还怕它占用过多资源，就可以使用yield（）方法，给其他重要的线程先工作。

  三、volatile与Java内存模型（JMM）

  Volatile:通过加入内存屏障和禁止重排序优化来实现
• 对volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的共享变量值刷新到主内存。

在这里插入图片描述

• 对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量。

  
  
  在这里插入图片描述

• volatile可以保证可见性但是不能保证原子性。例如下面的代码：

public class CountExample {

    //请求总数
    public static int clientTotal  = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;
    //计数 *
    public static volatile int count = 0;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();//创建线程池
        final Semaphore semaphore = new Semaphore(threadTotal);//定义信号量，给出允许并发的数目
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);//定义计数器闭锁
        for (int i = 0;i{
                try {
                    semaphore.acquire();//判断进程是否允许被执行
                    add();
                    semaphore.release();//释放进程
                } catch (InterruptedException e) {
                    log.error("excption",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();//保证信号量减为0
        executorService.shutdown();//关闭线程池
        log.info("count:{}",count);
    }

    private static void add(){
        count++;
    }
}

多次运行代码我们发现：count的最终结果并不是预期的5000，而是有时为5000，但是大多数时间比5000小，这是为什么呢？原因在于对count++的操作中，jvm对count做了三步操作：

1、从主存中取出count的值放入工作变量 count 
2、对工作变量中的count进行+1 
3、将工作变量中的count刷新回主存中

在单线程执行此操作绝对没有问题，但是在多线程环境中，假设有两个线程A、B同时执行count++操作，某一刻A与B同时读取主存中count的值，然后在自己线程对应的工作空间中对count+1，最后又同时将count+1的值写回主存。到此，count+1的值被写回主存两遍，所以导致最终的count值小了1。在整体程序执行过程中，该事件发生一次或多次，自然结果就不正确。
那么volatile适合做什么呢？其实它比较适合做状态标记量（不会涉及到多线程同时读写的操作），而且要保证两点：
（1）对变量的写操作不依赖于当前值
（2）该变量没有包含在具有其他变量的不变的式子中

package chapter2;

/**
 * NoVisibility class
 *
 * @author Flc
 * @date 2019/7/12
 */
public class NoVisibility {
    private volatile static boolean ready = false;
    private static int number;

    private static class ReaderThread extends Thread {
        public void run() {
            while(!ready) {
                System.out.println(number);
            }
            System.out.println("ok");
        }
    }
    private static class ReaderThread2 extends Thread {
        public void run() {
            try {
                Thread.sleep(2000);
                ready = true;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ReaderThread().start();
        new ReaderThread2().start();
    }
}

四、分门别类的管理：线程组

• 在一个系统中，如果线程数量很多，而且功能分配比较明确，就可以将相同功能的线程放在同一个线程组里。
• 线程组实现较为简单，具体实现如下：

public class ThreadGroupName implements Runnable {
    public static void main(String[] args) {
        ThreadGroup tg = new ThreadGroup("PringGroup");
        Thread thread1 = new Thread(tg, new ThreadGroupName(), "T1");
        Thread thread2 = new Thread(tg, new ThreadGroupName(), "T2");
        thread1.start();
        thread2.start();
        System.out.println(tg.activeCount());
        tg.list();
    }

    @Override
    public void run() {
        String groupAndName = Thread.currentThread().getThreadGroup().getName()
                + "-" + Thread.currentThread().getName();

        while (true) {
            System.out.println("I am " + groupAndName);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

五、驻守后台：守护进程（Daemon）

• 守护进程是一种特殊的线程，就和它的名字一样，它是系统的守护者，在后台默默完成一些系统性服务。比如垃圾回收线程，JIT线程就可以理解为守护线程。
• 与之相对应的是用户线程，用户线程可以认为是系统的工作线程，它会完成这个程序应该要完成的业务操作
• 如果用户线程全部结束，则意味着这个程序实际上上无视可做了，守护进程要守护的对象也就不存在了，那么整个应用就结束了。
• 下面简单实现一下守护进程

public class DaemonDemo {

    public static class DaemonT extends Thread {

        public void run() {
            while(true) {
                System.out.println("I am alive");
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new DaemonT();
        t.setDaemon(true);
        t.start();
        Thread.sleep(2000);
    }
}

六、先做重要的事：线程优先级

• Java中的线程可以有自己的优先级。优先级高的线程在竞争资源时会更有优势，更可能抢占资源。（优先级高也不一定意味着一定可以抢占资源）

• 在Java中，使用1到10表示线程优先级。一般可以使用内置的三个静态标量表示

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

• 数字越大则线程优先级越高。例如下面的例子：

public class PriorityDemo {
    public static class HightPriority extends Thread {
        static int count = 0;
        public void run() {
            while(true) {
                synchronized (PriorityDemo.class) {
                    count++;
                    if(count > 100000) {
                        System.out.println("High Priority is complete");
                        break;
                    }
                }
            }
        }
    }

    public static  class LowPriority extends Thread {
        static int count = 0;
        public void run () {
            while (true) {
                synchronized (PriorityDemo.class) {
                    count++;
                    if(count > 100000) {
                        System.out.println("Low Priority is complete");
                        break;
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        HightPriority high = new HightPriority();
        LowPriority low =new LowPriority();
        high.setPriority(Thread.MAX_PRIORITY);
        low.setPriority(Thread.MIN_PRIORITY);
        low.start();
        high.start();
    }
}

七、线程安全的概念与关键字syschronized

• 程序并行化是为了获得更高的执行效率，但前提是，高效率不能以牺牲正确性为代价。
• volatile关键字并不能保证线程安全。它只能保证一个线程修改数据之后，其他线程能够看到这个改动。
• 关键字synchronized的作用是实现线程之间的同步。它的工作是对同步的代码加锁，使得每一次，只能有一个线程进入同步块，从而保证线程间的安全性。
• synchronized关键字有如下几种用法
  1、指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。

public class AccountingSync implements Runnable {

    static AccountingSync instance = new AccountingSync();

    static int j = 0;

    @Override
    public void run() {
        for(int i = 0; i < 100000; i++) {
            synchronized (instance) {
                j++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(j);
    }
}

2、直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁

public class AccountingSync2 implements Runnable {
    static AccountingSync2 instance = new AccountingSync2();
    static int i = 0;
    public synchronized void increase() {
        i++;
    }


    @Override
    public void run() {
        for(int j = 0; j < 100000; j++) {
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

3、直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

public static synchronized void increase(){
    i++;
}

• 关键字synchronized可以保证线程安全，可见性和有序性。可以完全替代volatile关键字
• 线程解锁前，必须把共享变量的最新值刷新到主内存
• 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（注意：加锁与解锁是同一把锁）