齐齐哈尔百姓网:多线程高并发编程(1) -- 基础及详解

admin 1个月前 (04-26) 科技 5 2

靠山:

  历程和线程的区别:

  历程的内存大小为:堆内存+线程数目*栈内存线程数目 =( 最大地址空间[MaxProcessMemory] - JVM堆内存 - 系统保留内存[ReservedOsMemory] )/ ThreadStackSize(XSS)从中可以看出,线程的数目随栈内存的增多而削减。

  线程是程序执行的一个路径,每一个线程都有自己的局部变量表、程序计数器(指向正在执行的指令指针)以及各自的生命周期。当启动了一个Java虚拟机(JVM)时,从操作系统最先就会建立一个新的历程(JVM历程),JVM历程将会派生或者建立许多线程。

  • 一个线程的建立肯定是由另一个线程完成的;
  • 被建立线程的父线程是建立它的线程;

  线程会带来分外的开销,如CPU调剂时间、并发控制开销等;每个线程在自己的事情内存交互,加载和存储主内存控制欠妥会造成数据不一致。

一.线程建立方式:

  • 组织Thread类:实现线程的执行单元run有两种方式,分别是下面

    • 继续Thread,重写run方式:Thread实现了Runnable接口,使用start开启线程,start开启后线程会加入调剂器,然后挪用run方式,start会挪用start0内陆方式跟OS举行交互运行;下面是start源码剖析

      /**
       * Causes this thread to begin execution; the Java Virtual Machine
       * calls the <code>run</code> method of this thread.
       * 开启线程,JVM会挪用run方式【start使用了模板方式】
       * <p>
       * It is never legal to start a thread more than once.
       * 不能两次启动线程,否则报IllegalThreadStateException异常
       * In particular, a thread may not be restarted once it has completed
       * execution.
       * 一个线程生命周期竣事,也就是到了TERMINATED状态,再次挪用start方式是不允许的,
       * 也就是TERMINATED状态没法回到RUNNABLE/RUNNING状态。
       *
       * @exception  IllegalThreadStateException  if the thread was already
       *               started.
       * @see        #run()
       * @see        #stop()
       */
      public synchronized void start() {//线程平安的
          /**
           * This method is not invoked for the main method thread or "system"
           * group threads created/set up by the VM. Any new functionality added
           * to this method in the future may have to also be added to the VM.
           * 这个方式不会被主线程挪用或通过虚拟机系统线程组建立起来。未来任何添加到该方式里的新功能可能需要加入到虚拟机中
           *
           * A zero status value corresponds to state "NEW".
      * 线程被组织后的new状态,threadStatus的属性值是0
      */ if (threadStatus != 0) throw new IllegalThreadStateException(); /* Notify the group that this thread is about to be started * so that it can be added to the group's list of threads * and the group's unstarted count can be decremented.
      * 通知线程组新线程将要启动,以便它可以添加到线程组列表而且线程组没有最先计数
      */ group.add(this);//加入线程组 boolean started = false; try { start0();//挪用内陆方式 started = true; } finally { try { if (!started) {//启动失败 group.threadStartFailed(this);//线程启动失败,从组中移除该线程 } } catch (Throwable ignore) { /* do nothing. If start0 threw a Throwable then it will be passed up the call stack */ } } }
      void add(Thread t) {
      synchronized (this) {
      if (destroyed) {//线程组状态校验
      throw new IllegalThreadStateException();
      }
      if (threads == null) {
      threads = new Thread[4];//初始化长度为4的线程组
      } else if (nthreads == threads.length) {
      threads = Arrays.copyOf(threads, nthreads * 2);//数组满了就扩容2倍
      }
      threads[nthreads] = t;//当前线程添加到线程组中

      // This is done last so it doesn't matter in case the
      // thread is killed
      nthreads++;//线程数+1

      // The thread is now a fully fledged member of the group, even
      // though it may, or may not, have been started yet. It will prevent
      // the group from being destroyed so the unstarted Threads count is
      // decremented.
      nUnstartedThreads--;//未启动线程数-1
      }
      }
      private native void start0();//内陆方式挪用重写的run方式
      void threadStartFailed(Thread t) {
      synchronized(this) {
      remove(t);//移除当前线程
      nUnstartedThreads++;//没有启动的线程数目+1
      }
      }

      //=======================测试============================
      Thread t = new Thread(){
        @Override
        public void run(){
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
      };
      t.start();
      t.start();//不能两次启动,第二次启动是不允许的,报IllegalThreadStateException,此时该线程是处于运行状态
      //=======================测试============================== Thread t = new Thread(){ @Override public void run(){ try { TimeUnit.SECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } } }; t.start(); TimeUnit.SECONDS.sleep(10);//设置休眠时间,上面的线程的生命周期已经终止,下面再次启动报IllegalThreadStateException t.start();
    • 实现Runnable接口,重写run方式而且将Runnable实例用作组织Thread的参数【单继续有局限性,推荐使用接口】:将线程的控制(start)和营业逻辑(run)的运行彻底星散开来,使用的是计谋模式;Thread的run方式是不能共享的,但Runnbale的run方式可以共享,使用同一个Runnable的实例组织差别的Thread实例;把实现类工具(实现Runnable接口的类的实例化)放入署理类工具(Thread组织方式)中,使用的是署理模式;下面是静态署理的代码注释:

      public class StaticProxy {
          public static void main(String[] args) {
              new Weeding(new Me()).happyMarry();
      //        new Thread(工具).start();类似
          }
      }
      
      interface Marry {
          void happyMarry();
      }
      //真实角色
      class Me implements Marry {
          @Override
          public void happyMarry() {
              System.out.println("me will marry!");
          }
      }
      //署理工具
      class Weeding implements Marry{
          //真实角色
          private Marry marry;
          public Weeding(Marry marry){
              this.marry=marry;
          }
          @Override
          public void happyMarry() {
              System.out.println("start");
              marry.happyMarry();
              System.out.println("end");
          }
      }
  • 实现Callable接口,重写call方式,Future获取返回值:Callable能接受一个泛型,然后在call方式中返回一个指定类型的值;

    public interface Callable<V> {
        V call() throws Exception;
    } 
    //线程池行列开启线程,不会发生脏读数据
    //使用步骤: //1.建立目的工具new
    //2.建立执行服务线程池
    //3.提交执行submit
    //4.获取结构get
    //5.关闭服务shutdownNow
    public class MyThread implements Callable {
        private static int count = 20;
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            MyThread m1 = new MyThread();
            MyThread m2 = new MyThread();
            MyThread m3 = new MyThread();
            MyThread m4 = new MyThread();
            ScheduledExecutorService service = new ScheduledThreadPoolExecutor(2,
                    new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build());
            Future submit = service.submit(m1);
            Future submit1 = service.submit(m2);
            Future submit2 = service.submit(m3);
            Future submit3 = service.submit(m4);
            System.out.println(submit.get());
            System.out.println(submit1.get());
            System.out.println(submit2.get());
            System.out.println(submit3.get());
            service.shutdown();
    
        }
    
        @Override
        public Object call() throws Exception {
            count--;
            return count;
        }
    }
  • 匿名内部类;

            new Thread(){//相当于继续Thread的方式
                public void run(){
                    System.out.println("thread1 start ... ");
                }
            }.start();
    
    
            new Thread(new Runnable() {//相当于实现Runnable接口的方式
                @Override
                public void run() {
                    System.out.println("thread2 start .... ");
                }
            }).start();
  • 定时器(Timer);

            Timer timer = new Timer();//建立时间器
            timer.schedule(new TimerTask() {//使用schedule,参数为定时器义务并重写run方式
                @Override
                public void run() {
                    System.out.println("timer task is run");
                }
            }, 0, 1000);
  • 线程池(内部使用行列,以是加入线程池的线程是顺序执行):使用execute和重写Runnbale的run方式;

    ScheduledExecutorService service = new ScheduledThreadPoolExecutor(2,
                    new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build());
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("run test");
                }
            });
  • lambda表达式;

            new Thread(()-> {
                for(int i = 1 ; i<10 ; i++){
                    System.out.println("It is a lambda function!");
                }
    
            }).start();
  • Spring方式(@Async注解);

        @Test
        public void test() {
            run();
        }
        @Async
        public void run(){
            System.out.println("Async Test");
        }

二.线程生命周期

  • new新生状态:当用new建立一个Thread工具时,此时它并不处于执行状态,由于没有挪用star启动该线程,那么线程的状态为new状态,也就是说,它只是Thread工具的状态,在没有start之前,该线程是不存在的

  • runnable停当状态:线程工具进入runnable停当状态必须挪用start方式,那么此时才是真正地在JVM历程中建立了一个线程停当状态不会直接进入阻塞状态和殒命状态,即使是在线程的执行逻辑中挪用wait、sleep或其他block的IO操作等,也必须先获得CPU的调剂执行权才可以,严格来说,停当状态的线程只能意外终止或进入运行状态;

  • running运行状态:一旦CPU通过轮询或其他方式从义务可执行行列中选中了线程,此时它才气真正地执行自己的逻辑代码一个正在running状态的线程事实上也是一个runnable的,然则反过来则不建立;

 

  • sleep:使当前线程进入指定毫秒级的休眠,暂停执行,但不会放弃monitor锁的所有权,即不会释放锁资源;使用TimeUnit来替换Thread.sleep,省去了时间单元的换算步骤;

  • yield:属于一种启发式的方式,其会提醒调剂器我愿意放弃当前的CPU资源,若是CPU的资源不重要,则会忽略这种提醒;yield只是一个提醒(hint),CPU调剂器并不会担保每次都能知足yield提醒;

  • sleep和yield的区别:

    • sleep会导致当前线程暂停指定的时间,没有CPU时间片的消耗;

    • yield只是对CPU调剂器的一个提醒,若是CPU调剂器没有忽略这个提醒,它会导致线程上下文的切换;

    • sleep会使线程短暂block,会在给定的时间内释放CPU资源;

    • yield会使running状态的线程进入runnable状态(若是CPU调剂器没有忽略这个提醒的话);

    • sleep险些百分之百地完成了给定时间的休眠,但yield的提醒并不能一定担保;

    • 一个线程sleep另一个线程interrupt会捕获到中止信号,而yield则不会;

  • join:join某个线程A,会使当前线程B进入守候,直到线程A竣事生命周期;可以使用join来到达线程顺序执行的效果

  • wait:示意线程一直守候,直到其他线程通知,与sleep差别的是它会释放锁;挪用wait会加入wait set中;

  • notify:叫醒一个处于守候状态的线程;

  • notifyAll:叫醒同一个工具上所有挪用wait方式的线程,优先级高的线程优先调剂

  • synchronized:同步,内置锁、互斥锁,锁定共享资源(共享资源工具不能为null),JVM指令是monitor enter和monitor exit;synchronized的指令严格遵守java happens-before规则,一个monitor exit指令之前肯定要有一个monitor enter;

    • 锁信息存在工具头中:

      • Mark Word

        • 线程id

        • Epoch

        • 工具的分代岁数信息

        • 是否是偏向锁

        • 锁标志位

      • Class Metadata Address

,

sunbet

www.0379st.com信誉来自于每一位客户的口碑,Sunbet贴心的服务,让你尊享贵宾通道,秒速提现,秒速到账,同行业中体验最佳。

Allbet声明:该文看法仅代表作者自己,与本平台无关。转载请注明:齐齐哈尔百姓网:多线程高并发编程(1) -- 基础及详解

网友评论

  • (*)

最新评论

  • 天津新闻网 2020-04-19 00:22:55 回复

    诚信在线诚信在线(www.hoteluniformcustom.com)现已开放诚信在线手机版下载。游戏公平、公开、公正,用实力赢取信誉。这个很温暖的笔风

    1
  • sunbet 2020-04-26 00:18:04 回复

    诚信在线手机版诚信在线(现:阳光在线官网)现已开放诚信在线手机版、诚信在线电脑客户端下载。诚信在线娱乐游戏公平、公开、公正,用实力赢取信誉。板凳排排坐围观~

    2

站点信息

  • 文章总数:437
  • 页面总数:0
  • 分类总数:8
  • 标签总数:970
  • 评论总数:117
  • 浏览总数:3358