多线程

• 线程通讯

  • java.long.Object

    • wait() 释放了所持有的监视器对象上的锁，导致当前的线程等待

    • notify() 随机唤醒等待的线程

    • notifyAll() 唤醒正在等待一个给定对象的所有线程

• 管道流通讯

  • 死锁

    • 在一个线程中同时使用管道输入流和管道输出流

  • sleep和wait的区别

    • sleep方法由Thread类提供，不会释放线程锁

    • wait方法由Object类提供，所有java类都具备wait方法，导致当前的线程等待，直到其他线程调用此对象的notify()或notifyAll()

• 线程高级调度

  • 线程池

    • 概念

      • 一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后启用这些任务

      • 线程池线程都是后台线程

    • 作用

      • 解决线程生命周期开销问题和资源不足问题

    • 模式

      • HS/HA半同步/半同步模式

        • 同步层

        • 队列层

        • 异步层

      • L/F领导者与随意者模式

        • 领导者leader

        • 追随者 follower

        • 工作者processor

      • 组成

        • 线程池管理器 ThreadPooManager 创建管理线程池

        • 工作线程 WorkThread 线程池中线程

        • 任务接口 Task 每个任务必须实现的接口，以供工作线程调度任务的执行

        • 任务队列 存放没有处理的任务，提供一种缓冲基准

        • 执行以下线程：

          class ExecutorThread extends Thread{

            boolean funningFlag=false;

            private Runnable callBack=null;

            public void setCallBack(Runnable callBack){

              this.callBack=callBack;

            }

            public synchronized void setRunning(boolean flag){

              runningFlag=flag;

              if(flag)

                this.notify();//如果flag为true说明希望执行线程处理某一个具体的任务

            }

            public synchronized void run(){

              try{

                 while(true){

                    if(!runningFlag){

                       this.wait();//任务执行结束后阻塞本线程

                     }else{

                       callBack.run();

                       setRunning(false);

                    }

                }

              }catch(Exception e){}

            }

          }

        • 调度器

          public class ThreadExecutor{

            private List<ExecutorThread>thread;

            public ThreadPoolExecutor(int threadCount){

              threads=Collection.synchronizedList(new ArrayList<ExecutorThread>());

              for(int i=0;i<threadCount;i++){

                ExcutorThread thread=new ExcutorThread();

                threads.add(thread);

                thread.start();

              }

            }

            public void execute(Runnable callBack){

              int i;

              for(int i=0;i<callBack;i++){

                ExecutorThread currentThread=thread.get(i);

                if(!currentThread.runningFlag){

                  currentThread.setCallBack(callBack);

                  currentThread.setRunning(true);

                  return;

                }

              }

               if(i==threeads.size()){

                 System.out.println("线程资源已用完，请稍等片刻")

               }

            }

          }

  • 信号量 Semaphore

    • 信号灯

    • 多线程环境下使用的一种设施，负责协调各个线程，以保证它们能够正确、合理的使用公共资源

    • 信号量提供一个方法添加一个许可，从而可能释放一个正在阻塞的获取者

    • 实现示例：

      public class Semaphore{

        private List<Object> locks=Collections.synchronizedList(new ArrayList<Object()>);

        private int permitNum=1;

        private int nowPermitNum=1;

        private boolean permitNumGrow=false;

        Random random=new Random();
      

        public Semaphore(int permitNum,boolean permitNumGrow,boolean fair){

          this.ppermitNum=permitNum;

          this.permitNumGrow=permitNumGrow;

          this.fair=fair;

        }

        public Semaphore(int permitNum){

          this(permitNum,true,false);

        }

        public Semaphore(){

          this(i);

        }

        public void acquire(){

          Object lock=new Object();

          synchronized(lock){

            if(nowPermitNum>0){

              nowPermitNum--;

            }else{

              locks.add(lock);

              try{

                lock.wait();//如果当前没有可用许可则等待

              }catch(Exception x){

                ex.printStackTracce();

              }

            }

          }

        }

        public void release(){

          if(locks.size>0){

            int index=0;

            if(!fair){

              index=Math.abs(random.nextInt())%locks.size();

            }

            Object lock=new lock.get(index);

            locks.remove(lock);

            synchronized(lock){

              lock.notify();

            }

          }else if(nowPermitNum<permitNum || permitGrow){

            nowPermitNum++;

          }

        }

        public int getAvablePermitNum(){

          reutrn nowPermitNum;

        }

      }

  • 生产者-消费者模式

    • 概念

      • 一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者从仓库取走产品

      • 生产者-消费者=仓库

    • 规则

      • 仓库未满时生产，仓满停止生产

      • 消费者有产品时消费，仓空等待

      • 当消费者发现仓储没有产品时则通知生产者生产

      • 当生产者生产出可消费产品时，应通知消费者去消费

  • 线程池调度器

    • Executor框架 可以提交可执行任务的工具

    • Executors 主要工具类 提供一系列工厂方法用来创建任务执行器，返回的任务执行器都实现了ExecutorService接口

      • 主要接口

        • ScheduledExecutorSeervice

        • ExecutorService 异步的管理一个或多个线程终止、执行过程(Future)的方法

        • Executor 替代显示的创建和运行线程

    • ExecutorService

      • executor(Runnable) 接收一个java.long.Runnable对象作为参数

         public class ExecutorRunnableTest{

          public static void main(String args[]){

            ExecutorService executorService=Executors.newStrignThreadExcutor(); //创建执行器

            excutorService.excutor(new Runnable(){ //调度任务

              public void run(){

                System.out.println("执行异步任务");

              }

            });

            excutorService.shutdown();

          }

        }

      • submit(Runnable)

        public class SubmitRunnableTest{

          public static void main(String args[]){

            ExecutorService executorService=Executors.newStrignThreadExcutor(); //创建执行器

            Future future=excutorService.submit(new Runnable(){

              public void run(){

                System.out.println("执行异步任务");

              }

            });

            System.out.println("future.get()+"+future.get());//调用get()方法会导致线程阻塞直到异步任务执行完成，Runnable无法返回结果，因此始终获取到null
        

          }

        }

      • submit(Callable)

        • 有返回值

        • 可以从submit(Callable)返回的Future对象中获取

      • invokeAny()

        • 接收一个包含Callable对象的集合作为参数

        • 不返回Future对象

        • 如有任务运行完毕或抛出异常，方法会取消它的Callable的执行

      • invokeAll()

        • 调用存在参数集合中的索引Callable对象

        • 返回一个包含Future对象的集合

        • 可能会有异常导致运行结束，不代表运行成功

    • 立即关闭ExecutorService

      • shutdownNow()

  • 锁对象 Lock 接口

    • 默认实现 ReentrantLock

      • 可重入的独占锁 与synchronized 有相同的表现和更清晰的语义

      • 公平锁

      • 非公平锁

  • ThreadLocal 线程局部变量

    • 访问

      • get()

      • set()

      • remve()

      • initialValue()

      • get()

    • 作用

      • 解决多线程程序的并发问题

      • 是Thread的局部变量

      • 目标变量是线程的本地变量

  • 原子操作类

    • 概念

      • 相当于泛化的volatile变量

      • 支持原子读取-修改-写操作

    • java.util.concurrent.atomic 包四种类型的原子更新类

      • 原子更新基本类型

      • 原子更新数组类型

      • 原子更新引用

      • 原子更新属性

    • 原子更新基本类型

      • AtomicBoolean

      • AtomicInteger

      • AtomicLong

    • 通过原子更新数组里的某个元素

      • AtomicIntegerArray 整形

      • AtomicLongArray 更新长整形数组某个元素

      • AtomicReferenceArray 更新引用类数组的某个元素

    • AtomicIntergerArray常用方法

      • int addAndSet(int i,int delta) 以原子方式将输入值与数组中索引为i的元素相加

      • boolean compareAndSet(int i,int expect,int update) 如果当前值等于预期值，则以原子方式更新数组中索引为i的值为update值

    • 更新引用类型涉及的变量

      • AtomicReference 原子更新引用类型

      • AtomicReferenceFiledUpdater 原子更新引用类型里的字段

      • AtomicMarkableReference 原子更新带有标记位的引用类型

    • 更新字段类

      • AtomicIntegerFieldUpdater 原子更新整形字段

      • AtomicLongFiledUpdater 原子更新长整形字段

      • AtomicStampedReference 原子更新带有版本号的引用类型

    • 原子更新字段方法

      • 每次必须使用newUpdater创建一个更新器，设置想要跟新的类的字段

      • 更新类的字段(属性)必须为public volatile