Java--JUC--入门介绍

1.  JUC(java.util.concurrent)
   1. 进程/线程

      1. 进程:一个程序, QQ.exe Music.exe 程序的集合;
         一个进程往往可以包含多个线程，至包含一个!

      2. Java默认有几个线程? 2个mian、 GC

      3. 线程:了一个进程Typora,字,自动保存(线程负责的)
         对于Java而言: Thread、Runnable、 Callable

      4. Java真的可以开启线程吗?开不了

         　　
   2. 并发/并从

      • 并发编程:并发、并行

      • 并发(多线程操作同一个资源)
        ●CPU-核,模拟出来多条线程,天下武功,唯快不破,快速交替

      • 并行(多个人- -起行走)
        ●CPU多核,多个线程可以同时执行;线程池

      • package com. kuang. demo01;
        pub1ic class Test1 {
        pub1ic static void main(String[] args) {
        //获取cpu的 核数
        // CPU密集型，I0密集型
        Sys tem. out. println(Runtime. getRunt ime() . availableProcessors();
        }
        }

      • 并发编程的本质:充分利用CPU的资源

2. 三个包

   1. java . util. concurrent

   2. java . util . concurrent. atomic

   3. java . util. concurrent. locks

3. 多线程匿名内部类的方式实现：

   1. package com.model.concurrent;
      
      import java.util.concurrent.locks.Lock;
      import java.util.concurrent.locks.ReentrantLock;
      
      public class SaleTicketDemo01{
      static class Ticket {
          private int number=30;
          Lock lock=new ReentrantLock();
          public void sale(){
              lock.lock();
              try {
                  if (number>0) {
                      System.out.println(Thread.currentThread().getName() + "卖出第" + (number--) + "还剩下：" + number);
                  }
              }catch (Exception e){
                  e.printStackTrace();
              }finally {
                  lock.unlock();
              }
          }
      }
      
          public static void main(String[] args) {
          Ticket ticket= new Ticket();
      
              new Thread(new Runnable() {
                  @Override
                  public void run() {
                      for (int i=1;i<=40;i++) {
                          ticket.sale();
                      }
                  }
              },"A").start();
              new Thread(new Runnable() {
                  @Override
                  public void run() {
                      for (int i=1;i<=40;i++) {
                          ticket.sale();
                      }
                  }
              },"B").start();
              new Thread(new Runnable() {
                  @Override
                  public void run() {
                      for (int i=1;i<=40;i++) {
                          ticket.sale();
                      }
                  }
              },"C").start();
          }
      
      
      }
      
      class Ticket {
          private int number=30;
          Lock lock=new ReentrantLock();
          public void slave(){
              lock.lock();
              try {
                  System.out.println(Thread.currentThread().getName()+"没出第"+(number--)+"还剩下："+number);
              }catch (Exception e){
                  e.printStackTrace();
              }finally {
                  lock.unlock();
              }
          }
      }

       

      　　　　
4. 拉姆发表达式实现方式：

   1. package com.model.concurrent;
      
      import java.util.concurrent.locks.Lock;
      import java.util.concurrent.locks.ReentrantLock;
      
      public class SaleTicketDemo01{
      static class Ticket {
          private int number=30;
          Lock lock=new ReentrantLock();
          public void sale(){
              lock.lock();
              try {
                  if (number>0) {
                      System.out.println(Thread.currentThread().getName() + "卖出第" + (number--) + "还剩下：" + number);
                  }
              }catch (Exception e){
                  e.printStackTrace();
              }finally {
                  lock.unlock();
              }
          }
      }
      
          public static void main(String[] args) {
          Ticket ticket= new Ticket();
          
              new Thread(() ->{ for (int i=1;i<=40;i++) { ticket.sale(); } },"A").start();
              new Thread(() ->{ for (int i=1;i<=40;i++) { ticket.sale(); } },"B").start();
              new Thread(() ->{ for (int i=1;i<=40;i++) { ticket.sale(); } },"C").start();
          }
      
      
      }
      
      class Ticket {
          private int number=30;
          Lock lock=new ReentrantLock();
          public void slave(){
              lock.lock();
              try {
                  System.out.println(Thread.currentThread().getName()+"没出第"+(number--)+"还剩下："+number);
              }catch (Exception e){
                  e.printStackTrace();
              }finally {
                  lock.unlock();
              }
          }
      }

5. 线程的五个状态

   1. public enum State {
          
            //新建状态
              NEW,
      　　   //运行状态
              RUNNABLE,
             //  阻塞状态
              BLOCKED,
             //等待状态，死死的等
              WAITING,
             //超时等地，过期不候
              TIMED_WAITING,
      　　     //终止
              TERMINATED;

6. wait和sleep的不同
   1. 来自的类不同
      • wait（）来自Object类
      • sleep（）来自Thread类　　
   2. 关于锁的释放不同
      • wait（）等待是会释放锁
      • sleep（）睡觉，抱着锁睡，不会释放锁　　
   3. 使用范围不同
      • wait（）只能在同步代码块中使用
      • sleep可以在任何地方使用　　
   4. 是否捕获异常　　　　
      • wait不需要捕获异常
      • sleep需要捕获异常