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<clientTotal;i++){
            executorService.execute(()->{
                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关键字
  • 线程解锁前,必须把共享变量的最新值刷新到主内存
  • 线程加锁时,将清空工作内存中共享变量的值,从而使用共享变量时需要从主内存中重新读取最新的值(注意:加锁与解锁是同一把锁)
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值