Java并发编程-1.多线程基础

1 基础知识点

1.1 线程与进程的概念

• 进程： 每个正在系统上运行的程序都是一个进程，每个进程包含多个线程。进程是所有线程的集合，每一个线程是进程中额度一条执行路径。
• 线程： 线程是一条执行路径，多线程是为了提高程序的效率。如果有大量的线程，会影响性能。操作系统在多个线程之间切换，更多的线程需要更多的内存空间，线程的中止需要考虑对程序运行的影响。

1.2 同步与异步区别

• 同步： 同步是指一个进程在执行某个请求的时候，如果该请求需要一段时间才能返回信息，那么这个进程会一直等待下去，直到收到返回信息才继续执行下去。

• 异步： 异步是指进程不需要一直等待下去，而是继续执行下面的操作，不管其他进程的状态，当有信息返回的时候会通知进程进行处理，这样就可以提高执行的效率了，即异步是我们发出的一个请求，该请求会在后台自动发出并获取数据，然后对数据进行处理，在此过程中，我们可以继续做其他操作，不管它怎么发出请求，不关心它怎么处理数据。

2.多线程创建方式

2.1 继承Thread类，重写run方法

#创建线程
class DemoThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("demo thread 1");
    }
}

#使用线程
public static void main(String[] args) {
	DemoThread1 thread1 = new DemoThread1();
	thread1.start();
}

2.2 实现runable接口

#创建线程
class DemoThread2 implements Runnable {

    public void run() {
        System.out.println("demo thread 2");
    }
}

#使用线程
public static void main(String[] args) {
	//创建线程
	DemoThread2 demoThread2 = new DemoThread2();
	//启动线程
	Thread t2 = new Thread(demoThread2);
	t2.start();
}

2.3 匿名内部类方式

public static void main(String[] args) {
    Thread t3 =new Thread(new Runnable() {
        public void run() {
            System.out.println("demo thread 3");
        }
    });
    t3.start();
}

3.多线程状态

新建状态

• 使用new 创建一个线程时(new Thread())，线程还没有开始运行（没有调用start方法）

就绪状态

• 当线程对象调用了start方法即启动了线程，等待CPU分配执行权。
• 处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

运行状态

• 线程获得CPU执行权后，进入运行状态，开始执行run方法里代码

阻塞状态

线程运行过程中，由于原因进入阻塞状态：

• 1、线程通过调用sleep方法进入睡眠状态
• 2、线程调用在I/O上被阻塞的操作，可能存在等待用户输入操作
• 3、线图试图获取锁，但该锁资源被其他线程持有
• 4、线程等待其它条件触发

死亡状态

• 1、run方法正常执行完成后退出后，自然死亡
• 2、未捕获的异常终止run方法而使线程非自然死亡（猝死）

为了确定线程在当前是否存活着（1.正常运行 2.被阻塞），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡，则返回false.

4.线程分类

4.1 用户线程

• 用户线程是指自定义创建的线程，主线程停止，用户线程不会停止
• 用户线程是主线程创建的线程，用户线程与主线程互不影响

4.2 守护线程

• 守护线程当进程不存在或主线程停止，守护线程也会被停止
• 守护线程与主线程一起销毁，GC线程就是典型的代表
• 使用setDaemon(true)方法设置为守护线程

用户线程与守护线程执行案例

线程创建

class Demo4 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}

用户线程（非守护线程）执行

public static void main(String[] args) {
    Demo4 demo4 = new Demo4();
    demo4.start();
    for (int i = 0; i < 5; i++) {
        System.out.println(Thread.currentThread().getName() + "---" + i);
    }
}

执行结果：

#执行结果
main---0
main---1
main---2
main---3
main---4
Thread-0---0
Thread-0---1
Thread-0---2
Thread-0---3
Thread-0---4

守护线程执行

public static void main(String[] args) {
    Demo4 demo4 = new Demo4();
    demo4.setDaemon(true);
    demo4.start();
    for (int i = 0; i < 5; i++) {
        System.out.println(Thread.currentThread().getName() + "---" + i);
    }
}

执行结果：

#执行结果
main---0
main---1
main---2
main---3
main---4
Thread-0---0

由上面的执行结果可看出，

• 用户线程执行：主线程在执行完毕后，等待用户线程执行完毕后才结束执行
• 守护线程执行：主线程在执行完毕后，没有等待守护线程执行完毕而是终止了守护线程的执行

5.线程方法

join()方法

• join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。

• join方法中如果传入参数，则表示这样的意思：如果A线程中掉用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并行执行。需要注意的是，jdk规定，join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。(其实join()中调用的是join(0))

• join方法必须在线程start方法调用之后调用才有意义。这个也很容易理解：如果一个线程都没有start，那它也就无法同步了

• 样例：有T1，T2，T3三个线程，如何保证T1===>T2 ===>T3这样的执行顺序

  public static void main(String[] args) throws InterruptedException {
      Thread t1 = new Thread(new Runnable() {
          public void run() {
              for (int i = 0; i < 10; i++) {
                  System.out.println("t1,i:" + i);
              }
          }
      });
      Thread t2 = new Thread(new Runnable() {
          public void run() {
              for (int i = 0; i < 10; i++) {
                  System.out.println("t2,i:" + i);
              }
          }
      });
      Thread t3 = new Thread(new Runnable() {
          public void run() {
              for (int i = 0; i < 10; i++) {
                  System.out.println("t3,i:" + i);
              }
          }
      });
      t1.start();
      t1.join();
      t2.start();
      t2.join();
      t3.start();
  }
  

Yield()方法

• Thread.yield()方法的作用：暂停当前正在执行的线程，并执行其他线程。（可能没有效果）
• yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中
• 大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果

常用线程API方法

方法	用途
start()	启动线程
currentThread()	获取当前线程对象
getId()	获取当前线程ID Thread-编号 该编号从0开始
getName()	获取当前线程名称
sleep(long mill)	休眠线程
Stop（）	停止线程,

常用线程构造函数

构造函数	描述
Thread（）	分配一个新的 Thread 对象
Thread（String name）	分配一个新的 Thread对象，指定线程名称
Thread（Runable r）	分配一个新的 Thread对象
Thread（Runable r, String name）	分配一个新的 Thread对象