多线程复习总结之线程基础

进程与线程介绍

进程

一个在内存中运行的应用程序。
每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。

线程

进程中的一个执行任务（控制单元），负责当前进程中程序的执行。
1、一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。
2、与进程不同的是，同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈。所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

区别总结

根本区别：
进程是操作系统资源分配的基本单位，
而线程是处理器任务调度和执行的基本单位

资源开销：
每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；
线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

包含关系：
如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；
线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

内存分配：
同一进程的线程共享本进程的地址空间和资源，
而进程之间的地址空间和资源是相互独立的

影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

执行过程：
每个独立的进程有程序运行的入口、顺序执行序列和程序出口。
但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行

线程的生命周期

流程如下：

线程的基本状态

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。
根据阻塞产生的原因不同，阻塞状态又可以分为三种：
1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
2.同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
3.其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程的状态转换

1、 就绪状态转换为运行状态：当此线程得到处理器资源；
2、运行状态转换为就绪状态：当此线程主动调用yield()方法或在运行过程中失去处理器资源。
3、运行状态转换为死亡状态：当此线程线程执行体执行完毕或发生了异常。

【注意】当调用线程的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的哪个线程具有一定的随机性。因此，可能会出现A线程调用了yield()方法后，接下来CPU仍然调度了A线程的情况。

线程的创建方式

1、继承Thread类创建线程

public class ThreadTest extends Thread {
    /**
     * 重写run方法，run方法的方法体就是现场执行体
     **/
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(getName() + "  " + i);
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "  : " + i);
            new ThreadTest().start();
        }
    }
}

2、通过Runnable接口创建线程类

public class ThreadTest implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            ThreadTest rtt=new ThreadTest();
            new Thread(rtt, "新线程1").start();
            new Thread(rtt, "新线程2").start();
        }
    }
}

3、通过Callable和Future创建线程

public class ThreadTest {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        try {
            System.out.println("主线程正在执行任务");
            Thread.sleep(3000);
            Task task = new Task();
            Future<Integer> result = executor.submit(task);
            System.out.println("任务的运行结果：" + result.get());
            Thread.sleep(3000);
        } catch (InterruptedException | ExecutionException e1) {
            e1.printStackTrace();
        }
        System.out.println("所有的任务执行完毕");
        executor.shutdown();
    }
}

class Task implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程正在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 3; i++) {
            sum += i;
        }
        return sum;
    }
}

4、使用线程池创建线程

线程池分为很多种类，这里就不介绍了。想要了解的话，博主的这篇博客可能会有帮助：多线程复习总结之线程池的创建及使用

多线程的优缺点

使用原因

1、为了解决负载均衡问题
2、充分利用CPU资源
3、为了提高CPU的使用率
4、采用多线程的方式去同时完成几件事情而不互相干扰
5、为了处理大量的IO操作时或处理的情况需要花费大量的时间等等，比如：读写文件，视频图像的采集、处理、显示、保存等

优点

1、使用线程可以把占据时间长的程序中的任务放到后台去处理
2、用户界面更加吸引人，这样比如用户点击了一个按钮去触发某件事件的处理，可以弹出一个进度条来显示处理的进度
3、程序的运行效率可能会提高
4、在一些等待的任务实现上如用户输入，文件读取和网络收发数据等，线程就比较有用了.

缺点

1、如果有大量的线程，会影响性能，因为操作系统需要在它们之间切换
2、更多的线程需要更多的内存空间
3、线程中止需要考虑对程序运行的影响
4、通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生

多线程带来的问题

线程中的sleep和wait

sleep

1、sleep方法是Thread类的方法。
2、线程通过调用该方法，进入休眠状态主动让出CPU，从而CPU可以执行其他的线程。
3、经过sleep指定的时间后，CPU回到这个线程上继续往下执行。
4、若当前线程进入了同步锁，sleep()方法并不会释放锁。即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。

wait

1、wait()方法可以中断线程的运行，使本线程等待，暂时让出CPU的使用权，并允许其他线程使用这个同步方法。
2、其他线程如果在使用这个同步方法时不需要等待，那么它使用完这个方法的同时，应该用notifyAll()方法通知所有由于使用了这个同步方法而处于等待的线程结束等待，曾中断的线程就会从刚才中断处继续执行这个同步方法（并不是立马执行，而是结束等待），并遵循“先中断先继续”的原则。
3、wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法
【注】notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果

实例

package thread;
 
public class MultiThread {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Thread1()).start();
        Thread.sleep(5000);//主动让出CPU，让CPU去执行其他的线程。在sleep指定的时间后，CPU回到这个线程上继续往下执行
        new Thread(new Thread2()).start();
 
    }
}
  class Thread1 implements Runnable{
      @Override
      public void run() {
          synchronized (MultiThread.class){
              System.out.println("进入线程1");
              try{
                  System.out.println("线程1正在等待");
                  Thread.sleep(5000);
//                  MultiThread.class.wait();//wait是指一个已经进入同步锁的线程内（此处指Thread1），让自己暂时让出同步锁，
                                            //以便其他在等待此锁的线程(此处指Thread2)可以得到同步锁并运行。
 
              }catch(Exception e){
                  System.out.println(e.getMessage());
                  e.printStackTrace();
              }
              System.out.println("线程1结束等待，继续执行");
              System.out.println("线程1执行结束");
          }
      }
  }
  class Thread2 implements Runnable{
      @Override
      public void run() {
          synchronized (MultiThread.class){
              System.out.println("进入线程2");
              System.out.println("线程2唤醒其他线程");
              MultiThread.class.notify();//Thread2调用了notify()方法，但该方法不会释放对象锁，只是告诉调用wait方法的线程可以去
                                            //参与获得锁的竞争了。但不会马上得到锁，因为锁还在别人手里，别人还没有释放。如果notify()
                                            //后面的代码还有很多，需要执行完这些代码才会释放锁。
              try {
                  Thread.sleep(5000);
              }
              catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println("线程2继续执行");
              System.out.println("线程2执行结束");
          }
      }
  }

线程中的start和run

【面试考点】为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？

new 一个 Thread，线程进入了新建状态。调用 start() 方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。 而直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。

附：参考资料

1、为什么要使用多线程？多线程的优点和缺点是什么？
2、使用多线程可能会遇到的问题