Java中多线程的使用

1. 程序、进程、线程的理解

1.1 程序（program）

是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

1.2 进程（process）

程序的一次执行过程，或是正在运行的一个程序。

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

1.3 线程（thread）

进程可进一步细化为线程，是一个程序内部的一条执行路径。

线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。

1.4 补充

内存结构图：

进程可以细化为多个线程。

每个线程，拥有自己独立的：栈、程序计数器。

多个线程，共享同一个进程的结构：方法区、堆。

2. 并行与并发

2.1 单核CPU与多核CPU的理解

单核CPU其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费。）但是因为CPU时间单元特别短，因此感觉不出来。
如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）

2.2 并行和并发的理解

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事情。
并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。

3. 创建多线程的两种方式

3.1 方式一：继承Thread类的方式

创建一个继承于Thread类的子类
重写Thread类的run() –>将此线程执行的操作声明在run()中
创建Thread类的子类的对象
通过此对象调用start()：

①启动当前线程

②调用当前线程的run()

说明两个问题：

问题一：我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。

问题二：如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()。

 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


//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
  //2. 重写Thread类的run()
  @Override
  public void run() {
    for (int i = 0; i < 100; i++) {
      if(i % 2 == 0){
        System.out.println(Thread.currentThread().getName() + ":" + i);
      }
    }
  }
}


public class ThreadTest {
  public static void main(String[] args) {
    //3. 创建Thread类的子类的对象
    MyThread t1 = new MyThread();

    //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
    t1.start();
    MyThread t2 = new MyThread();
    t2.start();


    //如下操作仍然是在main线程中执行的。
    for (int i = 0; i < 100; i++) {
      if(i % 2 == 0){
        System.out.println(Thread.currentThread().getName() + ":" + i + "***********main()************");
      }
    }
  }

}

3.2 方式二：实现Runnable接口的方式

创建一个实现了Runnable接口的类
实现类去实现Runnable接口中的抽象方法：run()
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start()

 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


//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{

  //2. 实现类去实现Runnable中的抽象方法：run()
  @Override
  public void run() {
    for (int i = 0; i < 100; i++) {
      if(i % 2 == 0){
        System.out.println(Thread.currentThread().getName() + ":" + i);
      }

    }
  }
}


public class ThreadTest1 {
  public static void main(String[] args) {
    //3. 创建实现类的对象
    MThread mThread = new MThread();
    //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
    Thread t1 = new Thread(mThread);
    t1.setName("线程1");
    //5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
    t1.start();

    //再启动一个线程，遍历100以内的偶数
    Thread t2 = new Thread(mThread);
    t2.setName("线程2");
    t2.start();
  }

}

3.3 两种方式的对比

在开发中，优先选择实现Runnable接口的方式

原因：

实现的方式没有类的单继承的局限性。
实现的方式更适合来处理多个多线程共享数据的情况。

方式一和方式二的联系：

实际上Thread类本身就实现了Runnable接口

1

public class Thread implements Runnable

相同点：两种方式都在需要重写run()方法，将线程要执行的逻辑声明在run()中。

目前两种方式，想要启动线程，都是调用的Thread类的start()。

4. Thread类中的常用方法

start():启动当前线程；调用当前线程的run()
run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread():静态方法，返回执行当前代码的线程
getName():获取当前线程的名字
setName():设置当前线程的名字
yield():释放当前cpu的执行权
join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
stop():已过时。当执行此方法时，强制结束当前线程。
sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
isAlive():判断当前线程是否存活

线程的优先级包括：

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 –>默认优先级

如何获取和设置当前线程的优先级：

getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级

说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。

补充说明: 线程分为守护线程和用户线程两种。

5. Thread的生命周期

说明：

生命周期关注两个概念：状态、相应的方法
关注：
- 状态a–>状态b:哪些方法执行了（回调方法）
- 某个方法主动调用：状态a–>状态b
阻塞：临时状态，不可以作为最终状态
死亡：最终状态

6. 线程的同步机制

背景：

窗口买票过程中，出现了重票、错票的时候，即出现了线程安全问题。

问题出现的原因：

当某个线程操作车票的过程中，尚未操作完成时，其他的线程参与进来，也操作了车票。

如何解决： 当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

在Java中，通过使用同步机制，解决线程的安全问题。

6.1 方式一：同步代码块

1
2
3


synchronized(同步监视器){
  // 需要被同步的代码块
}

说明：

操作共享数据的代码，即为需要被同步的代码。
共享数据：多个线程共同操作的变量。
同步监视器：俗称：锁🔒，可以是任何一个类的对象，但是要求多个线程必须共用同一把锁。

补充：

在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

 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
39
40
41
42
43


class Window1 implements Runnable{

  private int ticket = 100;
  @Override
  public void run() {
    while(true){
      synchronized (this){
        //此时的this:唯一的Window1的对象  
        if (ticket > 0) {
          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
          ticket--;
        } else {
          break;
        }
      }
    }
  }
}


public class WindowTest1 {
  public static void main(String[] args) {
    Window1 w = new Window1();

    Thread t1 = new Thread(w);
    Thread t2 = new Thread(w);
    Thread t3 = new Thread(w);

    t1.setName("窗口1");
    t2.setName("窗口2");
    t3.setName("窗口3");

    t1.start();
    t2.start();
    t3.start();
  }

}

6.2 方式二：同步方法

1
2
3


public synchronized void methodName(){
  
}

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本身

 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
39
40
41
42
43
44
45
46
47
48
49
50
51


class Window3 implements Runnable {

  private int ticket = 100;

  @Override
  public void run() {
    while (true) {

      show();
    }
  }

  private synchronized void show(){//同步监视器：this
    //synchronized (this){

    if (ticket > 0) {

      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

      System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);

      ticket--;
    }
    //}
  }
}


public class WindowTest3 {
  public static void main(String[] args) {
    Window3 w = new Window3();

    Thread t1 = new Thread(w);
    Thread t2 = new Thread(w);
    Thread t3 = new Thread(w);

    t1.setName("窗口1");
    t2.setName("窗口2");
    t3.setName("窗口3");

    t1.start();
    t2.start();
    t3.start();
  }

}

6.3 方式三：Lock锁—JDK5.0新增

面试题：synchronized和Lock的异同？

相同点：二者都可以解决线程安全问题
不同点：
- synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器。
- Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

使用的先后顺序：

Lock锁
同步代码块（已接进入方法体，分配了相应的资源）
同步方法（在方法体外）

 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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


class Window implements Runnable{

  private int ticket = 100;
  //1.实例化ReentrantLock
  private ReentrantLock lock = new ReentrantLock();

  @Override
  public void run() {
    while(true){
      try{

        //2.调用锁定方法lock()
        lock.lock();

        if(ticket > 0){

          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }

          System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
          ticket--;
        }else{
          break;
        }
      }finally {
        //3.调用解锁方法：unlock()
        lock.unlock();
      }

    }
  }
}

public class LockTest {
  public static void main(String[] args) {
    Window w = new Window();

    Thread t1 = new Thread(w);
    Thread t2 = new Thread(w);
    Thread t3 = new Thread(w);

    t1.setName("窗口1");
    t2.setName("窗口2");
    t3.setName("窗口3");

    t1.start();
    t2.start();
    t3.start();
  }
}

6.1 线程安全的单例模式（懒汉式）

使用同步机制将单例模式中的懒汉式改写为线程安全的。

 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


class Bank{

  private Bank(){}

  private static Bank instance = null;

  public static Bank getInstance(){
    //方式一：效率稍差，每个线程都需要先进入同步代码块，然后再拿到对象实例。
    //        synchronized (Bank.class) {
    //            if(instance == null){
    //
    //                instance = new Bank();
    //            }
    //            return instance;
    //        }
    //方式二：效率更高
    if(instance == null){

      synchronized (Bank.class) {
        if(instance == null){

          instance = new Bank();
        }

      }
    }
    return instance;
  }

}

6.2 死锁问题

什么叫死锁？ 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续
我们使用同步时，要避免出现死锁。

 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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


public static void main(String[] args) {

  StringBuffer s1 = new StringBuffer();
  StringBuffer s2 = new StringBuffer();


  new Thread(){
    @Override
    public void run() {

      synchronized (s1){

        s1.append("a");
        s2.append("1");

        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }


        synchronized (s2){
          s1.append("b");
          s2.append("2");

          System.out.println(s1);
          System.out.println(s2);
        }


      }

    }
  }.start();


  new Thread(new Runnable() {
    @Override
    public void run() {
      synchronized (s2){

        s1.append("c");
        s2.append("3");

        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }

        synchronized (s1){
          s1.append("d");
          s2.append("4");

          System.out.println(s1);
          System.out.println(s2);
        }
      }
    }
  }).start();


}

7. 线程通信

7.1 线程通信涉及到的三个方法

wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程。

说明：

wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

7.2 sleep()和wait()的异同

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
1. 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
2. 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
3. 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

7.3 释放锁的操作

7.4 不会释放锁的操作

8. JDK5.0新增线程创建的方式

8.1 新增方式一：实现Callable接口

创建一个实现Callable的实现类
实现call方法，将此线程需要执行的操作声明在call()中
创建Callable接口实现类的对象
将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
获取Callable中call方法的返回值

 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
39


//1.创建一个实现Callable的实现类
class NumThread implements Callable{
   //2.实现call方法，将此线程需要执行的操作声明在call()中
   @Override
   public Object call() throws Exception {
       int sum = 0;
       for (int i = 1; i <= 100; i++) {
           if(i % 2 == 0){
               System.out.println(i);
               sum += i;
           }
       }
       return sum;
   }
}


public class ThreadNew {
   public static void main(String[] args) {
       //3.创建Callable接口实现类的对象
       NumThread numThread = new NumThread();
       //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
       FutureTask futureTask = new FutureTask(numThread);
       //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
       new Thread(futureTask).start();

       try {
           //6.获取Callable中call方法的返回值
           //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
           Object sum = futureTask.get();
           System.out.println("总和为：" + sum);
       } catch (InterruptedException e) {
           e.printStackTrace();
       } catch (ExecutionException e) {
           e.printStackTrace();
       }
   }

}

说明：如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

call()可以返回值的。

call()可以抛出异常，被外面的操作捕获，获取异常的信息

Callable是支持泛型的

8.2 新增方式二：使用线程池的方式

 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
39
40
41
42
43
44
45
46


class NumberThread implements Runnable{

  @Override
  public void run() {
    for(int i = 0;i <= 100;i++){
      if(i % 2 == 0){
        System.out.println(Thread.currentThread().getName() + ": " + i);
      }
    }
  }
}

class NumberThread1 implements Runnable{

  @Override
  public void run() {
    for(int i = 0;i <= 100;i++){
      if(i % 2 != 0){
        System.out.println(Thread.currentThread().getName() + ": " + i);
      }
    }
  }
}

public class ThreadPool {

  public static void main(String[] args) {
    //1. 提供指定线程数量的线程池
    ExecutorService service = Executors.newFixedThreadPool(10);
    ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
    //设置线程池的属性
    //        System.out.println(service.getClass());
    //        service1.setCorePoolSize(15);
    //        service1.setKeepAliveTime();


    //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
    service.execute(new NumberThread());//适合适用于Runnable
    service.execute(new NumberThread1());//适合适用于Runnable

    //        service.submit(Callable callable);//适合使用于Callable
    //3.关闭连接池
    service.shutdown();
  }

}

说明：好处有：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没任务时最多保持多长时间后会终止

文章目录