线程与同步

一、线程

　　1.1多线程原理

　　我们先定义一个线程类，代码如下：

package com.buwei;

/**
 * @author buwei
 * @date 2018/12/24 20:07
 */
public class MyThread extends Thread {
    /**
     * 利用继承中的特点
     * 将线程名称传递,进行设置
     *
     * @param name 线程的名称
     */
    public MyThread(String name) {
        super(name);
    }

    /**
     * 重写run方法
     * 定义线程要执行的代码
     */
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            // getName（）方法来自父亲
            System.out.println(getName() + i);
        }
    }
}

　　再定义一个测试类，如下：

package com.buwei;

/**
 * @author buwei
 * @date 2018/12/24 20:15
 */
public class MyThreadTest {
    public static void main(String[] args) {
        MyThread mt = new MyThread("小强");
        // 开启新的线程
        mt.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财" + i);
        }
    }
}

　　执行流程图如下：

 

　　程序启动时运行main时候，Java虚拟机启动一个进程，主线程main在main()调用的时候被创建，随着调用mt对象的start方法，另外一个新的线程也启动了，这样，这个应用就在多线程下运行。要想让效果看起来更明显一些，我们可以让打印的次数更多一些来执行。

　　多线程在执行时，在栈内存中，每一个执行线程都有一片自己所属的栈内存空间，进行方法的压栈和弹栈。

　　当执行线程的任务结束了，线程自动在栈内存中释放了，但是当所有的执行线程都结束了，那么进程就结束了。

 　　1.2 Thread类

　　构造方法：

• public Thread()：分配一个新的线程对象
• public Thread(String name)：分配一个指定名字的新的线程对象
• public Thread(Runable target)：分配一个带有指定目标新的线程对象
• public Thread(Runable target，String name)：分配一个带有执行目标新的线程对象并指定名字

 　　常用方法：

• public String getName()：获取当前线程名称
• public void start()：导致此线程开始执行；Java虚拟机调用此线程的run方法
• public void run()： 此线程要执行的任务在此处定义代码
• public static void sleep(Long milllis)：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
• public static Thread currentThread()：返回对当前正在执行的线程对象的引用

 　　我们在查询API后可以得知创建线程的方式总共有两种，一种是继承Thread类方法，一种是时间Runable接口方式，前面的我们展示的是第一种，现在我们讲解第二种

　　1.3 创建线程的方式二

　　采用Java.lang.Runnable也是非常常见的方法之一，我们只需要重写run方法即可

　　步骤如下：

• 定义Runnable接口的实现类，并且重写该接口的run()方法，该run()方法的方法体同样是该线程的执行体
• 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
• 调用线程对象的start()方法来启动线程

　　代码如下：

package com.buwei;

/**
 * @author buwei
 * @date 2018/12/24 20:53
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

package com.buwei;

/**
 * @author buwei
 * @date 2018/12/24 20:55
 */
public class MyRunnableTest {
    public static void main(String[] args) {
        // 创建自定义类对象，线程任务对象
        MyRunnable mr = new MyRunnable();
        // 创建线程对象
        Thread t = new Thread(mr, "小强");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财" + i);
        }
    }
}

　　通过实现Runnable接口，使得该类有了多线程类的特性。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法中，Thread类实际上也是实现了Runnable接口的类。

　　在启动多线程的时候，需要先通过Thread类的构造方法Thread(Runnable targer)构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

　　实际上所有的所线程代码都是通过Thread的start()方法来运行的，因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

　　tips：Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run方法仅作为线程执行体。而时间的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

　　1.4 Thread和Runable的区别

　　如果一个类继承Thread，则不适合资源共享，但是如果实现了Runnable接口的话，则很容易的实现资源共享。

　　总结：实现Runnable接口比继承Thread类所具有的优势：

1. 适合锁哥相同的程序代码的线程去共享一个资源
2. 可以避免Java中出现单继承的局限性
3. 增加线程的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
4. 线程池只能放入实现Runnable或者Callable类线程，不能直接放入继承Thread的类

　　补充：在Java中，每次程序的运行至少启动两个线程。一个是main线程，一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实就是在操作系统中启动了一个进程

　　1.5 匿名内部类方式实现线程的创建

　　使用线程的匿名内部类的方式，可以方便的实现每个线程执行不同的线程操作。

　　使用匿名内部类的方式实现Runable接口，重写Runnable接口中的run()方法：

package com.buwei;

/**
 * @author buwei
 * @date 2018/12/24 21:15
 */
public class NoNameInnerClassThread {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("小强" + i);
                }
            }
        };
        new Thread(r).start();
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财" + i);
        }
    }
}

二、线程安全

　　2.1 线程安全

　　如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行的结构单线程一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

　　我们用一个生活中常见的电影院卖票的案例来演示线程的安全问题：

　　我们模拟电影院现在要播放一场电影，《楚门的世界》，本次电影总共是有100个座位，三个窗口同时开启卖票。

　　用线程对象来模拟窗口，票的张数来模拟Runnable接口的子类

package com.buwei;

/**
 * @author buwei
 * @date 2018/12/24 21:24
 */
public class Ticket implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        // 每个窗口都可以执行卖票，窗口全部开启
        while (true){
            // 有票可以卖
            if (ticket > 0){
                try {
                    // sleep模拟出票时间
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 获取当前线程对象的名字
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖第" + ticket-- + "张票");
            }
        }
    }
}

package com.buwei;

/**
 * @author buwei
 * @date 2018/12/24 21:29
 */
public class TicketTest {
    public static void main(String[] args) {
        // 创建线程任务对象
        Ticket ticket = new Ticket();
        // 创建撒个窗口对象
        Thread thread1 = new Thread(ticket, "窗口1");
        Thread thread2 = new Thread(ticket, "窗口2");
        Thread thread3 = new Thread(ticket, "窗口3");

        //三个窗口同时卖票
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

　　这时候就会出现问题：

　　后面的票提前卖，票被超卖，以及票被重复卖等等问题。

　　这种问题，就是因为几个窗口的票数不同步了，我们称之为线程不安全

　　线程安全问题都是由全局变量和静态变量引起的，如果每个线程对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量时线程安全的，但是如果有多个线程同时执行写操作，我们就要考虑线程安全的问题了。

　　2.2 线程同步

　　Java中对于多线程的问题提供了同步机制（synchronized）来解决这个问题。

　　有三种方式可以完成同步操作：

• 同步代码块
  • synchronized关键字可以用于方法中的某个区域中，表示对这个区块的资源实行互斥访问，格式如下：

  • synchronized（同步锁）{
         需要同步操作的代码  
    }

• • 同步锁：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁
    • 锁对象可以是任意类型
    • 多个线程对象要使用同一把锁
    • 注意：在任何时候，最多允许一个线程拥有同步锁进入代码块，其他的线程只能在外面等着

    • package com.buwei;
      
      /**
       * @author buwei
       * @date 2018/12/24 21:24
       */
      public class Ticket implements Runnable {
          private int ticket = 100;
      
          @Override
          public void run() {
              // 每个窗口都可以执行卖票，窗口全部开启
              synchronized (this){
                  while (true){
                      // 有票可以卖
                      if (ticket > 0){
                          try {
                              // sleep模拟出票时间
                              Thread.sleep(100);
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                          // 获取当前线程对象的名字
                          String name = Thread.currentThread().getName();
                          System.out.println(name + "正在卖第" + ticket-- + "张票");
                      }
                  }
             }
          }
      }

• 同步方法
  • 使用synchronized修饰的方法，就叫做同步方法，保证线程A执行该方法的时候其他线程只能在方法外等着，格式如下：

  • public synchronized void method(){
        可能会产生线程安全问题的代码  
    }

  • 对于非static方法，同步锁就是this
  • 对于static方法，我们使用当前方法所在类的字节码对象（类名.class）
  • 使用同步方法代码如下：

  • package com.buwei;
    
    /**
     * @author buwei
     * @date 2018/12/24 21:24
     */
    public class Ticket implements Runnable {
        private int ticket = 100;
    
        @Override
        public void run() {
            // 每个窗口都可以执行卖票，窗口全部开启
            while (true) {
                sellTicket();
            }
        }
    
        public synchronized void sellTicket(){
            // 有票可以卖
            if (ticket > 0){
                try {
                    // sleep模拟出票时间
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 获取当前线程对象的名字
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖第" + ticket-- + "张票");
            }
        }
    }

•  Lock锁：java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象

• public void lock()：加同步锁
• public void unlock()：释放同步锁
• public void trylock()：如果获取锁的时候锁被占用就返回false，否则返回true
• 使用如下：

• package com.buwei;
  
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  /**
   * @author buwei
   * @date 2018/12/24 21:24
   */
  public class Ticket implements Runnable {
      private int ticket = 100;
  
      Lock lock = new ReentrantLock();
  
      @Override
      public void run() {
          // 每个窗口都可以执行卖票，窗口全部开启
          while (true) {
              lock.lock();
              // 有票可以卖
              if (ticket > 0) {
                  try {
                      // sleep模拟出票时间
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  // 获取当前线程对象的名字
                  String name = Thread.currentThread().getName();
                  System.out.println(name + "正在卖第" + ticket-- + "张票");
              }
              lock.unlock();
          }
      }
  }

 三、线程状态

 　　3.1 线程状态概述

 　　当线程被创建并启动以后，它即不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，在线程的生命周期中，在Java.lang.Thread.State枚举类中给了六种线程状态：

　　3.2 Timed Waiting（计时等待）

　　描述：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。

　　在我们在的run方法方法中添加sleep语句就是所谓的TimedWaiting计时等待

• 进入Timed_Waiting状态的一种常见情形是调用的sleep方法，单独的线程也可以调用，不一定非要有协作关系
• 为了让其他线程有机会执行，可以将Thread.sleep()的调用放在线程run()之内，这样才能保证该线程执行过程中睡眠
• sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态

 　　sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始like执行

 　　Timed Waiting线程状态图

　　3.3 Blocked(锁阻塞)

 　　描述：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

　　比如：线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，name线程B就进入到Blocked锁阻塞状态。

　　这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，Blocked线程状态图如下：

　　3.4 Waiting（无线等待）

 　　描述：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

　　Waiting线程状态图：

　　

　　3.5 补充知识点

　　tips：我们在翻阅API的时候会发现Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系还是很紧密的，比如Waiting（无限等待） 状态中wait方法是空参的，而timed waiting（计时等待） 中wait方法是带参的。这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来；如果在倒计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。

四、Lock锁和synchronized的区别

　　下表来自：https://blog.csdn.net/u012403290/article/details/64910926