Java多线程基础

一. 进程和线程概念

• 进程：是一个运行在内存中的程序，当一个程序进入内存中运行，就成了一个进程。就好比电脑上打开微信，当双击微信图标使其运行时，微信就会变成系统的一个进程，进入内存中运行了。

  

  进程有三个特征：

  独立性：进程是独立的，每一个进程都有自己的内存空间。

  动态性：程序并不是进程，只是静态的代码指令，而进程是正在系统中活动的，是一个动态的概念。

  并发性：并发性是指多个进程可以在单个CPU上并发执行。

  补漏：

  并发：是指多个事件在同一时间段中发生。（不同时发生）

  并行：是指多个事件在同一时刻发生。（同时发生）

  在单核CPU系统中，每一时刻只有一个程序运行，并发指的是从宏观上看，每个程序好像是同时发生，但从微观上看，每个程序时交替运行的，只不过这个交替运行时间很短，很快速的切换。

  但在多核CPU系统中，这些多个程序的并发，就可以分配到多个CPU上运行，实现并行，也就是真正的同时运行了。

• 线程：线程是系统能够运行运算调度的最小单元，它是进程中的一个执行单元，是进程中的实际运作的单位，一个进程中至少有一个线程（主线程），一个进程可以拥有多个线程。

二. 线程的创建

Java中使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

1.Java中有两种方式创建线程：

• 继承Thread类创建线程类，重写run方法。

  1. 定义继承自Thread的子线程类，重写run()方法。（run()方法为线程的执行体)
  2. 创建子线程类的实例对象
  3. 调用实例对象的start()方法开启线程

  // 1. 定义继承自Thread的子线程类
  public class ChildThread extends Thread {
      // 重写run()方法。（run()方法为线程的执行体)
      @Override
      public void run() {
          System.out.println("我是一个线程...");
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8

  public class Test1 {
      public static void main(String[] args) {
          // 2. 创建子线程类的实例对象
          ChildThread ct = new ChildThread();
  	   // 3. 调用实例对象的start()方法开启线程
          ct.start();
          System.out.println("我是main线程");
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9

• 实现Runnable接口创建线程类

  1. 定义实现Runnable接口的实现类，重写接口的run()方法。（run()方法为线程的执行体）
  2. 创建Runnable接口实现类实例对象，并将该实例对象作为参数，传递给Thread类构造函数，创建Thread对象。(创建的Thread对象才是真正的线程对象)
  3. 调用Thread对象的start()方法开启线程

  // 1. 定义实现Runnable接口的实现类，重写接口的run()方法。
  public class ChildRunnable implements Runnable {
      @Override
      public void run() {
          for(int i = 0; i < 5; i++) {
              System.out.println("我是一个线程...");
          }       
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9

  public class Test1 {
      public static void main(String[] args) {
          // 2. 创建Runnable接口实现类实例对象，并将该实例对象作为参数，传递给Thread类构造函数
          ChildRunnable cr = new ChildRunnable();
          Thread t = new Thread(cr);
  	    // 3. 调用Thread对象的start()方法开启线程
          t.start();
          for(int i = 0; i < 5; i++) {
              System.out.println("我是main线程");
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

注意：关于Thread类的start()和run()方法

1. start()方法是用来启动新建的线程，run()方法只是一个普通方法，直接调用run()方法并不会创建线程，程序仍旧是在当前线程中运行。
2. start()方法不能重复调用，而run()可以。
3. start()内部调用了run()方法，star()里面的run代码可以不执行完就继续执行下面的代码（也就是进行了线程切换），而直接调用run()方法，就必须等待全部代码执行完才能继续往下执行(跟普通方法一样)

2.两种创建方式的对比

推荐使用实现Runnable接口的方式创建多线程，主要是实现Runnable接口的方式比较具有优势，主要为：

• Java中继承是不支持多继承，只有单继承，使用实现Runnable接口的方式，线程类只是实现了接口，还可以继承其他类，而如果已经继承了Thread类，就无法再继承其他类了。
• 比较适合多个相同程序处理同一资源的情况，分离了数据和代码，提高程序健壮性，实现解耦操作。
• Java线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类。

三.线程的状态

Java线程有六种状态，在java.lang.Thread.State中给出了六种线程状态：

• NEW(新建)：至今尚未启动的线程处于这种状态。
• RUNNABLE(可运行)：线程在java虚拟机中运行的状态，可能在运行，也可能在等待调度。
• BLOCKED(阻塞)：线程阻塞等待状态，比如当一个线程试图获取一个对象锁，但锁被其他线程占用，则该线程进入BLOCKED状态，而当线程获取到锁时，将变成RUNNABLE状态。
• WAITING(无限等待)：线程等待状态，进入这个状态后是无法自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才可以唤醒。
• TIMED_WAITING(计时等待)：具有指定等待时间的线程等待状态，这一状态将保持到超时或者收到唤醒状态，带有超时参数的常用方法有：Thread.sleep,Object.wait,Thread.join
• TEMINATED(终止)：线程的终止状态，线程正常执行完成或者出现异常而结束。

对应状态转换图如下：

四.线程类Thread常用的方法

• Thread类构造方法

  public Thread()	分配一个新的线程对象
  public Thread(String name)	分配一个指定名字的新的线程对象
  public Thread(Runnable target)	分配一个带有指定目标新的线程对象
  public Thread(Runnable target, String name)	分配一个带有指定目标新的线程对象并指定名字

• 常用方法

  public void start()	使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
  public void run()	如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
  public final void setName(String name)	改变线程名称，使之与参数 name 相同。
  public final void join(long millisec)	等待该线程终止的时间最长为 millis 毫秒。
  public final boolean isAlive()	测试线程是否处于活动状态。

• 静态方法

  public static void yield()	暂停当前正在执行的线程对象，并执行其他线程。
  public static void sleep(long millisec)	在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
  public static Thread currentThread()	返回对当前正在执行的线程对象的引用。

五.线程同步与通信

当有多个线程同时运行时，如果每个线程都要访问共有资源，就可能造成线程安全问题。

比如典型的多线程售票问题，多个线程同时售票，但票的总数是一定的，每个线程卖出了票都会更新总票数，同时进行就可能造成了数据混乱了。

线程安全问题都是由全局变量及静态变量引起的。

1.线程同步

线程同步机制(synchronized)是Java中提供的一种解决线程安全问题的方式。

• 线程安全问题提出

  比如：模拟电影院售票，实现多个窗口同时售票

  public class Ticket implements Runnable {
      private int ticket = 100;
  
      // 线程执行卖票操作
      @Override
      public void run() {
          while (true) {
              // 如果有票，就可以卖
              if (ticket > 0) {
                  // 使用sleep模拟一下出票时间
                  try {
                      Thread.sleep(100);
                  } catch(InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket-- + "张票");
              }   
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20

  public class Demo {
      public static void main(String[] args) {
          Ticket ticket = new Ticket();
  
          // 创建三个售票窗口
          Thread t1 = new Thread(ticket, "窗口1");
          Thread t2 = new Thread(ticket, "窗口2");
          Thread t3 = new Thread(ticket, "窗口3");
  
          // 同时卖票
          t1.start();
          t2.start();
          t3.start();
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

  运行结果出现如下现象：出现了窗口2卖第-1张，窗口3卖第0张的情况。

  出现这种状态就是因为线程不同步。
  
  原理：假设当前卖到剩下1张票，线程1先抢的CPU开始运行，运行到Thread.sleep处睡眠，让出CPU，此时，ticket=1；这时候线程3抢到了CPU开始运行，ticket仍是1，线程3也运行到Thread.sleep处睡眠，这时候线程1醒了，重新获得CPU运行，把票卖了，这时ticket=0，这时候线程3获得了CPU，继续运行，再卖一张票，这时ticket已经是0了，所以又卖了一张，ticket就变成了-1，这种现象就出现了。

• 线程安全问题解决

  使用同步解决线程安全问题，有以下三种：

  同步代码块，同步方法，锁机制。

  1. 同步代码块

     同步代码块使用关键字：synchronized,用于方法中的某个区块，表示只对这个区块的资源进行互斥访问。

     格式为：

     synchronized (对象锁) {
         需要同步的代码
     }
     1
     2
     3

     对象锁：这里的同步锁，只是一个概念，可以想象为在对象上标记了一个锁，锁对象可以是任意类型的，但是多个线程对象要用同一把锁才可以。

     使用同步代码块解决上述售票问题：

     public class Ticket implements Runnable {
         private int ticket = 100;
     
         Object lock = new Object();
         // 线程执行卖票操作
         @Override
         public void run() {
             while (true) {
                 synchronized (lock) {
                      // 如果有票，就可以卖
                     if (ticket > 0) {
                         // 使用sleep模拟一下出票时间
                         try {
                             Thread.sleep(100);
                         } catch(InterruptedException e) {
                             e.printStackTrace();
                         }
                         System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket-- + "张票");
                     }  
                 }
                 
             }
         }
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24

     注意：上面的lock也可以用this，代表使用当前对象为锁对象。

  2. 同步方法

     同步方法：就是使用关键字synchronized修饰方法，被修饰的方法就叫同步方法。

     格式为：

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

     注意：同步方法，其实也是用了锁对象，对于非static方法，同步方法的锁对象就是this；对于static方法，锁对象就是当前方法所在类的字节码对象(类名.class)

     使用同步方法解决上述售票问题：

     public class Ticket implements Runnable {
         private int ticket = 100;
     
         // 线程执行卖票操作
         @Override
         public void run() {
             while (true) {
                 sellTicket();
             }
         }
     
         public synchronized void sellTicket() {
             if (ticket > 0) {
                 // 使用sleep模拟一下出票时间
                 try {
                     Thread.sleep(100);
                 } catch(InterruptedException e) {
                     e.printStackTrace();
                 }
                 System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket-- + "张票");
             }  
         }
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23

  3. 锁机制

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

     锁机制也称同步锁，使用方法进行加锁和解锁，主要API如下：

     public void lock()：加同步锁

     public void unlock()：释放同步锁

     使用方法：

     创建Lock类的子类对象(ReentrantLock())，调用lock()或unlock()方法

     import java.util.concurrent.locks.Lock;
     import java.util.concurrent.locks.ReentrantLock;
     
     public class Ticket implements Runnable {
         private int ticket = 100;
     
         Lock lock = new ReentrantLock();
     
         // 线程执行卖票操作
         @Override
         public void run() {
             while (true) {
                 lock.lock();
                 if (ticket > 0) {
                     // 使用sleep模拟一下出票时间
                     try {
                         Thread.sleep(100);
                     } catch(InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket-- + "张票");
                 }  
                 lock.unlock();
             }
         }
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26

2.线程通信

上述线程同步针对的是多个线程共享同一个资源的情况，线程间通信则是指多个线程共同处理同一个资源，但是彼此的执行动作是不一样的。

典型的例子就是生产者与消费者的问题了。

比如：线程A是生产者，用来生产包子，线程B是消费者，用来吃包子，包子就是他们共享的同一资源，但线程A和线程B的动作是不一样的，一个负责生产，一个负责消费，这就存在双方通信问题了。

Java中有一个内建的等待机制来允许线程在等待信号的时候变成非运行状态，java.lang.Object类定义了三个方法来实现这个等待机制：wait()、notify()、notifyAll()

wait()：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁，这时线程在等待别的线程执行一个“通知(notify)”的动作。线程被唤醒后重新进入到调度队列。

notify()：选取所通知对象的wait set中的一个线程释放。（随机选择）

notifyAll()：释放所通知对象的wait set上的全部线程。

一个线程一旦调用了任意对象的wai()方法，就会变成非运行状态，直到另一个线程调用了同一个对象的notify()方法/notifyAll()方法，为了调用wait()或者notify()，线程就必须先获得那个对象的锁，因此线程必须是在同步块里调用wait()或者notify()

所以调用wait和notify方法需要注意以下细节：

• wait方法和notify方法必须由同一个锁对象调用。因为：调用wait方法等待后，需要同一个锁对象调用notify才可以唤醒。
• wait方法与notify方法是属于Object类的方法，因为：锁对象可以是任意对象，而任意对象又是继承了Object类的
• wait方法和notify方法必须要在同步代码块或者同步方法中使用，因为：必须要通过锁对象调用者两个方法

注意：

即使notify只通知了一个等待的线程，被通知的线程也不能立即恢复运行，因为当初中断的地方是在同步块内，而此刻它已经不再具有锁了，所以需要重新去获取锁（这就面临竞争），获取成功后才会在wait方法之后恢复执行。

代码演示生产者生产包子，消费者吃包子

资源——包子

public class Resource {
    String pi;              // 包子皮
    String xian;            // 包子馅
    boolean flag = false;   // 包子资源是否存在
}
1
2
3
4
5

生产者——包子铺

public class Productor extends Thread {
    private Resource baozi;

    public Productor(String name, Resource bz) {
        super(name);
        this.baozi = bz;
    }

    @Override
    public void run() {
        // 做包子
        synchronized (baozi) {
            while(true) {
                // 有包子，那就等待
                if (baozi.flag == true) {
                    try {
                        baozi.wait();
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 没有包子，做包子
                System.out.println("生产者开始制作包子...");
                baozi.pi = "薄皮";
                baozi.xian = "牛肉";
                baozi.flag = true;
                System.out.println("包子做好了：" + baozi.pi + baozi.xian);
                try {
                    Thread.sleep(1000);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }
                // 唤醒等待线程
                baozi.notify();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

消费者——吃包子的人

public class Consumer extends Thread {
    private Resource baozi;

    public Consumer(String name, Resource bz) {
        super(name);
        this.baozi = bz;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (baozi) {
                if (baozi.flag == false) {  // 没有包子可以吃， 那就等待
                    try {
                        baozi.wait();
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                   
                }
                System.out.println("消费者正在吃" + baozi.pi + baozi.xian + "包子");
                System.out.println("======================");
                baozi.flag = false;
                baozi.notify();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

测试主类：

public class Demo {
    public static void main(String[] args) {
        Resource baozi = new Resource();

        // 两个线程都用同一资源，作为线程的锁对象
        Productor productor = new Productor("生产者", baozi);
        Consumer consumer = new Consumer("消费者", baozi );

        consumer.start();
        productor.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

六. 线程池

1. 为啥要用线程池？

   因为当我们需要用到线程时候就创建一个，实现起来是很方便的，但会有个问题，那就是当并发的线程数很多时候，而且任务是比较短的结束，这样频繁的创建线程就会降低系统的效率了，因为系统创建线程和销毁线程都是需要时间的。

   所以可以使用线程池来实现这样的效果：在线程执行完一个任务后，并不去销毁，而是可以继续执行其他的任务。

2. 线程池概念

   线程池其实就是一个容器，可以容纳多个线程，这里面的线程可以反复使用，不用频繁创建新的线程，降低资源消耗，提高响应速度，提高线程的可管理性。

3. 线程池的使用

   Java里面线程池的顶级接口是：java.util.concurrent.Executor,但严格意义上讲，Executor并不是一个线程池，而是一个执行线程的工具，真正的线程池接口是：java.util.concurrent.ExecutorService

   官方建议使用的是java.util.concurrent.Executors工程类来创建线程池对象

   主要方法是：

   • public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。（创建的是有界的线程池，可以指定线程池线程的最大个数）

   • public Future submit(Runnable task)：获取线程池中的某一个对象，并执行

     Future接口：用来记录线程任务执行完毕后产生的结果。

   使用线程池中线程对象的步骤：

   • 创建线程池对象
   • 创建Runnable接口子类对象(任务)
   • 提交Runnable接口的子类对象
   • 关闭线程池（一般不做）

   示例代码：

   public class Task implements Runnable {
       @Override
       public void run() {
           System.out.println("我要一个教练");
           try {
               Thread.sleep(1000);
           } catch(InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("教练来了：" + Thread.currentThread().getName());
           System.out.println("教我游泳，教完后，教练回到了游泳池");
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13

   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   
   public class ThreadPoolDemo {
       public static void main(String[] args) {
           // 创建线程池对象
           ExecutorService service = Executors.newFixedThreadPool(2);
           // 创建Runnable实例对象
           Task t = new Task();
   
           // 从线程池中获取线程对象，然后调用Task中的run方法
           service.submit(t);
           // 再获取线程对象
           service.submit(t);
           service.submit(t);
   
           // 关闭线程池
           // service.shutdown();
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20