Java多线程学习笔记

程序、进程、线程

  程序：是为了完成特定任务，用某种语言编写的一组指令的集合，是一段静态的代码。（程序是静态的）
  进程：是程序的一次动态执行。正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。（进程是动态的），进程的生命周期：有它自身的产生、存在和消亡的过程。
  线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。

单核CPU与多核CPU

  单核CPU：CPU在执行的时候，是按照时间片执行的，同一个时间片只能执行一个任务。执行多个任务时，会在多个任务之间来回跳。时间片切换很快，给人感觉像是在同时执行多个线程。是一种假象。
  多核CPU：多个CPU的时候，才真正意义上做到一个时间片多线程同时执行。多线程发挥了最好的效率。真正的多线程。

并行和并发

  并行：多个CPU同时执行多个任务。
  并发：一个CPU“同时”执行多个任务。（采用时间片切换）

在学习多线程之前，以前的代码都是单线程吗？

  不是，以前的代码也是多线程。除了main方法为主线程，还包括处理异常的线程和垃圾回收的线程。PS：处理异常的线程会影响主线程的执行。

创建线程的三种方式

1. 继承Thread类

    public class BuyTicketThread extends Thread{
        public BuyTicketThread(String name){
          super(name);
        }
        //一共10张票
        static int ticketNum = 10;//加上static，使得票数被三个线程共享，否则会售出30张票

        @Override
        public void run(){
            //每个窗口后面有100个人在抢票
            for (int i = 1; i <= 100; i++) {
                //票数大于0才售票
                if (ticketNum>0){
                    System.out.println("我在"+this.getName()+"抢到了从北京到邯郸的第"+ ticketNum-- +"张票");
                }

            }
        }
    }

    public class Test {
        public static void main(String[] args) {
            //多个窗口抢票
            BuyTicketThread buy1 = new BuyTicketThread("窗口1");
            buy1.start();
            BuyTicketThread buy2 = new BuyTicketThread("窗口2");
            buy2.start();
            BuyTicketThread buy3 = new BuyTicketThread("窗口3");
            buy3.start();
        }
    }

2.实现Runnable接口

  public class BuyTicketThread implements Runnable{
    int ticketNum = 10;
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            if (ticketNum > 0){
                System.out.println("我在"+Thread.currentThread().getName()+"买到了第"+ ticketNum-- +"张北京到邯郸的车票");
            }
        }
    }
  }
  public class Test {
    public static void main(String[] args) {
        //定义一个线程对象
        BuyTicketThread buy = new BuyTicketThread();
        //窗口1买票
        Thread thread1 = new Thread(buy,"窗口1");
        thread1.start();
        //窗口2买票
        Thread thread2 = new Thread(buy,"窗口2");
        thread2.start();
        //窗口3买票
        Thread thread3 = new Thread(buy,"窗口3");
        thread3.start();
    }
  }

3.实现Callable接口

  对比方式1和方式2，都需要有一个run方法，但是这个run方法有不足之处：没有返回值，不能抛出异常。
  基于上面两个不足，在JDK1.5之后出现了第三种创建多线程的方式：实现Callable接口：有返回值，可以抛出异常，但是创建比较麻烦。
  public class TestCallable implements Callable<Integer> {

      /**
       * 实现Callable接口可以不带泛型，如果不带则返回值是object类型
       * @return
       * @throws Exception
       */
      @Override
      public Integer call() throws Exception {
          return new Random().nextInt(10);//返回10以内的随机数
      }
  }

  public class Test {
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          //定义一个线程对象
          TestCallable tc = new TestCallable();
          FutureTask ft = new FutureTask(tc);
          Thread thread = new Thread(ft);
          thread.start();
          //获取线程的返回值
          Object obj = ft.get();
          System.out.println(obj);
      }
  }

方式1继承Thread类和方式2实现Runnable接口，实际开发中哪个方式更好？

  方式1在Java单继承中具有局限性，继承了Thread类，就不能继承其他类了。
  方式2的共享资源能力更强一些，变量不用加static来修饰也可以实现共享，方式1共享变量必须用static修饰。（为什么不用static也可以） https://blog.csdn.net/zuolovefu/article/details/40264719

Thread类和Runnable接口有什么关系？

  Runnable接口--实现-->Thread类，即Thread类实现了Runnable接口。（方式2的线程类实现了Runnable接口，方式1的线程类继承了Thread类。）

线程的生命周期

  新生状态、就绪状态、执行状态、死亡状态、阻塞状态。
  Thread thread = new Thread();新生状态-----start启动----》就绪状态（等待CPU调度）----run（）获取cpu执行权--------》运行状态-------正常结束/出现异常/调用stop方法（不建议，该方法已废弃）----------》死亡状态
  Thread thread = new Thread();新生状态-----start启动----》就绪状态（等待CPU调度）----run（）获取cpu执行权--------》运行状态-------阻塞事件----------》阻塞状态-------阻塞事件解除----------------》就绪状态
  Thread thread = new Thread();新生状态-----start启动----》就绪状态（等待CPU调度）----run（）获取cpu执行权--------》运行状态------调用wait方法----》等待队列-----调用notify/notifyall方法-------》锁池状态-------释放锁-》就绪状态
  Thread thread = new Thread();新生状态-----start启动----》就绪状态（等待CPU调度）----run（）获取cpu执行权--------》运行状态------synchronized----》锁池状态-----释放锁-----》就绪状态

线程的常见方法

  start（）：启动当前线程，表面上调用start方法，实际上执行run方法。
  run():线程类继承Thread或者实现runnable接口的时候，都要重写run方法，run方法里面是线程要执行的内容。
  currentThread:Thread类中的一个静态方法，获取正在执行的线程。
  setName():设置线程名称
  getName():获取线程名称
  setPriority(int num):设置优先级别方法：同优先级别的线程采取先到先服务，使用时间片策略。如果优先级高，被CPU调度的概率就高。级别为：1-10，默认是5。
      /**
   * The minimum priority that a thread can have.
   */
  public final static int MIN_PRIORITY = 1;

 /**
   * The default priority that is assigned to a thread.
   */
  public final static int NORM_PRIORITY = 5;

  /**
   * The maximum priority that a thread can have.
   */
  public final static int MAX_PRIORITY = 10;

设置优先级别

  public class TestThread01 extends Thread{
      @Override
      public void run() {
          for (int i = 0; i < 10; i++) {
              System.out.println(i);
          }
      }
  }
  public class TestThread02 extends Thread{
      @Override
      public void run() {
          for (int i = 20; i < 30; i++) {
              System.out.println(i);
          }
      }
  }
  public class Test {
      public static void main(String[] args) {
          TestThread01 thread01 = new TestThread01();
          thread01.setPriority(10);//优先级别高
          thread01.start();
          TestThread02 thread02 = new TestThread02();
          thread02.setPriority(2);//优先级别低
          thread02.start();
      }
  }

join方法

  当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程。注意：必须先start，再join才有效。
  public class TestThreadJoin extends Thread{
      public TestThreadJoin(String name){
          super(name);
      }

      @Override
      public void run() {
          for (int i = 0; i < 10; i++) {
              System.out.println(this.getName()+"----------"+i);
          }
      }
  }
  public class Test {
      public static void main(String[] args) throws InterruptedException {
          for (int i = 0; i < 100; i++) {
              System.out.println("main-------------"+i);
              if (i==6){
                  //创建子线程
                  TestThreadJoin ttj = new TestThreadJoin("join子线程");
                  ttj.start();
                  ttj.join();//等子线程执行完再执行主线程。子线程打印0-9
              }
          }
      }
  }

sleep方法

sleep人为制造阻塞事件
public class Test {
  public static void main(String[] args) throws InterruptedException {
      DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
      Date date = new Date();
      String format = dateFormat.format(date);
      System.out.println(format);
      Thread.sleep(3000);
  }
}

设置伴随线程

  将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了。不会立马结束，会垂死挣扎一会。
  public class TestThread extends Thread{
      @Override
      public void run() {
          for (int i = 0; i < 100; i++) {
              System.out.println("子线程--"+i);
          }
      }
  }
  class Test{
      public static void main(String[] args) {
          //创建并启动子线程
          TestThread thread = new TestThread();
          thread.setDaemon(true);//设置伴随线程，先设置，再启动
          thread.start();
          //主线程输出1到10
          for (int i = 0; i < 10; i++) {
              System.out.println("main---"+i);
          }
      }
  }

stop方法

//终止当前线程。
public class TestStop{
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            if (i==6){
                Thread.currentThread().stop();//过期方法，不建议使用
            }
            System.out.println(i);
        }
    }
}

同步代码块

买票代码出现的问题：
1.出现了两个或多个10张票。因为ticketNum--时，执行了两个操作，一个是打印ticketNum，一个是ticketNum减1，很可能在ticketNum没有执行减1操作时，被其他线程抢到了资源先打印出来，导致多售票的现象发生。
2.出现0或者-1，-2的情况。跟上述一样的情况，先执行了减1操作，后执行了打印。
上面代码出现的问题：出现了重票，多票。
原因：多个线程，在争抢资源中，导致共享的资源出现了问题。一个线程没执行完，另一个线程参与进来，开始争抢。
解决：在程序中加入锁。
方式1：同步代码块 this锁
 public class TestSyncThread implements Runnable{
    int ticketNum = 10;
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            synchronized (this) {//只把具有安全隐患的代码锁住即可，如果锁多了效率就会降低。-》this指的就是这个锁
                if (ticketNum>0){
                    System.out.println("我在"+Thread.currentThread().getName()+"买到了邯郸到北京的第"+ ticketNum-- +"张票");
                }
            }
        }
    }
 }
  public class Test {
      public static void main(String[] args) {
          TestSyncThread tst = new TestSyncThread();
          Thread thread = new Thread(tst,"窗口1");
          thread.start();
          Thread thread2 = new Thread(tst,"窗口2");
          thread2.start();
          Thread thread3 = new Thread(tst,"窗口3");
          thread3.start();
      }
  }
  同步代码块 字节码信息锁
  public class TestSyncLockThread extends Thread{
      static int ticketNum =10;
      @Override
      public void run() {
          for (int i = 1; i <= 100; i++) {
              synchronized (TestSyncLockThread.class) {
                  //必须是同一把锁，因为创建了三个Thread对象，如果这里用this，相当于用了三把锁。为了保证同一把锁，这里一般写类的字节码表示唯一。
                  if (ticketNum>0){
                      System.out.println("我在"+Thread.currentThread().getName()+"抢到了从北京到邯郸的第"+ ticketNum-- +"张票");
                  }
              }
          }
      }
  }

  public class Test {
      public static void main(String[] args) {
          Thread thread1 = new TestSyncLockThread();
          thread1.setName("窗口1");
          thread1.start();
          Thread thread2 = new TestSyncLockThread();
          thread2.setName("窗口2");
          thread2.start();
          Thread thread3 = new TestSyncLockThread();
          thread3.setName("窗口3");
          thread3.start();
      }
  }
同步监视器总结：synchronized(同步监视器){}，是写在括号中的叫做同步监视器。
1.必须是引用类型，不能是基本数据类型。
2.也可以创建一个专门的同步监视器，没有任何业务含义。Object o = new Object();
3.一般使用共享资源做同步监视器即可。如上面类的字节码。
4.在同步代码块中不能改变同步监视器的引用。错误示例：String syncStr = "abc";synchronized(syncStr){syncStr ="bcd";}
5.尽量不要用String和包装类Integer做同步监视器。
6.建议使用final修饰同步监视器。 final String syncStr = "abc";
同步代码块的执行过程：
1.第一个线程来到同步代码块，发现锁处于open状态，先进行close，然后执行代码块中的代码。
2.第一个线程在执行代码过程中出现了线程切换，（阻塞 就绪），失去了CPU，但是没有开锁open。
3.第二个线程来到同步代码块，发现锁处于close，无法执行代码块中的代码，第二个线程进入阻塞。
4.第一个线程重新拿到CPU，执行完代码，释放锁open。
5.第二个线程也再次拿到CPU，来到同步代码块，发现锁处于open状态，拿到锁并上锁，由阻塞状态变为就绪状态再变为执行状态，重复线程一的过程。
强调：同步代码块中能发生CPU的切换吗？能，但是后续的被执行的线程无法执行代码块中的代码，因为锁仍旧close。
总结：其他
1.多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块。
2.多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块。

同步方法

public class TestSyncMethod implements Runnable{
  int ticketNum = 10;
  @Override
  public void run() {
      for (int i = 1; i < 100; i++) {
          buyTicket();
      }
  }

  public synchronized void buyTicket(){//对这个方法加同步方法，锁住的是TestSyncMethod.class
      if (ticketNum>0){
          System.out.println("我在"+Thread.currentThread().getName()+"抢到了第"+ ticketNum-- +"张票");
      }
  }
}
public class Test {
  public static void main(String[] args) {
      TestSyncMethod method = new TestSyncMethod();
      Thread thread1 = new Thread(method,"窗口1");
      thread1.start();
      Thread thread2 = new Thread(method,"窗口2");
      thread2.start();
      Thread thread3 = new Thread(method,"窗口3");
      thread3.start();
  }
}

public class TestSyncMethod2 extends Thread{
  static int ticketNum = 10;
  @Override
  public void run() {
      for (int i = 1; i < 100; i++) {
          buyTicket();
      }
  }

  public static synchronized void buyTicket(){//用static修饰，锁住的是TestSyncMethod2.class
      if (ticketNum>0){
          System.out.println("我在"+Thread.currentThread().getName()+"抢到了第"+ ticketNum-- +"张票");
      }
  }
}
public class Test2 {
  public static void main(String[] args) {
      TestSyncMethod2 method1 = new TestSyncMethod2();
      method1.setName("窗口1");
      method1.start();
      TestSyncMethod2 method2 = new TestSyncMethod2();
      method2.setName("窗口2");
      method2.start();
      TestSyncMethod2 method3 = new TestSyncMethod2();
      method3.setName("窗口3");
      method3.start();
  }
}
总结：关于同步方法
1.不要将run()定义为同步方法。
2.非静态同步方法的同步监视器是this。静态同步方法的同步监视器是类的字节码对象。类.class
3.同步代码块的效率要高于同步方法。
  原因：同步方法是将线程挡在了方法的外部，而同步代码块可以进入方法，只是在代码块的外部，但却是在方法的内部。
4.同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法。同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他同步监视器的代码块。

lock锁

JDK1.5后新增新一代的线程同步方式线程锁，与采用synchronized相比，lock可提供多种锁方案，更灵活。
synchronized是Java中的关键字，属于虚拟机级别的锁。这个关键字是靠JVM来识别完成的。
Lock锁是API级别的，提供了相应的接口和实现类，这个方式更加灵活，表现出来的性能优于之前的方式。
###### 代码演示：
public class Test {
  public static void main(String[] args) {
      TestLock testLock = new TestLock();
      Thread thread = new Thread(testLock,"窗口1");
      thread.start();
      Thread thread2 = new Thread(testLock,"窗口2");
      thread2.start();
      Thread thread3 = new Thread(testLock,"窗口3");
      thread3.start();
  }
}
public class TestLock implements Runnable{
  int ticketNum = 10;
  //拿来一把锁
  Lock lock = new ReentrantLock();
  @Override
  public void run() {
      for (int i = 1; i <= 100; i++) {
          //打开锁
          lock.lock();
          try {
              if (ticketNum>0){
                  System.out.println("我在"+Thread.currentThread().getName()+"抢到了第"+ ticketNum-- +"张票");
              }
          } catch (Exception e) {
              e.printStackTrace();
          } finally {//将关闭锁放到finally中，即使代码异常也会关闭锁
              lock.unlock();
          }
      }
  }
}
lock锁和synchronized的区别：
1.lock是显示锁（手动开启和关闭锁，别忘了关闭锁），synchronized是隐式锁。
2.lock只有代码块锁，synchronized有代码块锁和方法锁。
3.使用lock锁，JVM花费较少的时间来调度线程，性能更好。并且具有更好的扩展性。（提供更多的子类）
使用的顺序：
Lock--同步代码块（已经进入了方法体，分配了相应的资源）--同步方法（在方法体之外）

线程同步的优缺点

1.对比：线程安全，效率低。线程不安全，效率高。
2.可能造成死锁：
  死锁：
    >不同的线程分别占用对方需要的同步资源不放弃，都在等待对方释放自己需要的同步资源，就形成了线程的死锁。
    >出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
3.代码演示：
  public class Test {
      public static void main(String[] args) {
          //实现两个线程类
          TestDeadLock testDeadLock1 = new TestDeadLock();
          TestDeadLock testDeadLock2 = new TestDeadLock();
          testDeadLock1.flag=1;
          testDeadLock2.flag=0;
          //开启两个线程
          Thread thread1 = new Thread(testDeadLock1);
          thread1.start();
          Thread thread2 = new Thread(testDeadLock2);
          thread2.start();
      }
  }
  public class TestDeadLock implements Runnable{
      public int flag = 1;
      //两个对象必须用static修饰，因为必须确定是唯一的元素
      static Object o1 = new Object(), o2 = new Object();
      @Override
      public void run() {
          System.out.println("flag=="+flag);
          if (flag == 1){
              synchronized (o1){
                  try {
                      Thread.sleep(500);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  synchronized (o2){//只需要锁住o2即可
                      System.out.println("o2");
                  }
              }
          }

          if (flag==0){
              synchronized (o2){
                  try {
                      Thread.sleep(500);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  synchronized (o1){//只需要锁住o1即可
                      System.out.println("o1");
                  }
              }
          }
      }
  }
4.解决办法：减少同步资源的定义，避免嵌套同步。

线程通信问题

在Java对象中，有两种池
锁池-----------------synchronized
等待池---------------wait(),notify(),notifyall()
如果一个线程调用了某个对象的wait方法，那么该线程进入到该对象的等待池中（并且已经将锁释放），
如果未来某个时刻，另外一个线程调用了相同对象的notify方法或者notifyall方法，
那么该等待池中的线程就会被唤醒，然后进入到该对象的锁池里面获取该对象的锁，
如果获得锁成功后，那么该线程就会沿着wait方法之后的路径继续执行。注意是沿着wait（）方法之后。

注意：
1. wait方法和notify方法 notifyall方法，必须放在同步代码块或者同步方法里才生效。（因为在同步的基础上进行线程的通信才是有效的）
2. sleep和wait的区别，sleep进入阻塞状态，没有释放锁；wait进入阻塞状态，释放了锁。

使用同步代码块，完成生产消费者通信代码存在的问题：
  生产者和消费者在同一个等待池里，如果同时存在多个消费者，则无法实现。解决思路，所有生产者放入一个等待池，所有消费者放入一个等待池。
使用lock锁来实现线程通信：
  lock拥有一个同步池和多个等待池，synchronized拥有一个同步池和一个等待池。