Java 多线程技术基础知识

Java 多线程技术

一、多线程的应用

大量应用于网络编程服务器端程序的开发,最常见的 UI 界面底层原理、操作系统底层原理都大量使用了多线程。

游戏中各种按钮,实现的底层就是多线程的应用,上万个人同时访问某个网站,也是基于网站服务器的多线程原理。

二、程序 进程 线程

  • 程序是一个静态的概念,是操作系统中的一个可执行文件,当启动程序时,就产生了进程。

  • 执行中的程序叫做进程,因此进程是一个动态的概念。

1. 进程是程序的一次动态执行过程, 占用特定的地址空间。

2. 每个进程由 3 部分组成:cpu、data、code。每个进程都是独立的,保有自己的 cpu 时间,代码和数据,即便用同一份程序产生好几个进程,它们之间还是拥有自己的这 3 样东西,这样的缺点是:浪费内存,cpu 的负担较重。

3. 多任务 (Multitasking) 操作系统将 CPU 时间动态地划分给每个进程,操作系统同时执行多个进程,每个进程独立运行。以进程的观点来看,它会以为自己独占 CPU 的使用权。

  • 一个进程可以产生多个线程。同多个进程可以共享操作系统的某些资源一样,同一进程的多个线程也可以共享此进程的某些资源 (比如:代码、数据),所以线程又被称为轻量级进程(lightweight process)。

​ 1. 线程是一个进程内部的一个执行单元,它是程序中的一个单一的顺序控制流程。

​ 2. 一个进程可拥有多个并行的 (concurrent) 线程

​ 3. 一个进程中的多个线程共享相同的内存单元/ 内存地址空间,可以访问相同的变量和对象,而且它们从同一堆中分配对象并进行通信、数据交换和同步操作。

​ 4. 由于线程间的通信是在同一地址空间上进行的,所以不需要额外的通信机制,这就使得通信更简便而且信息传递的速度也更快。

​ 5. 线程的启动、中断、消亡,消耗的资源非常少

三、线程和进程的区别

​ 1. 每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销。

​ 2. 线程可以看成是轻量级的进程,属于同一进程的线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器 (PC),线程切换的开销小。

​ 3. 线程和进程最根本的区别在于:进程是资源分配的单位线程是调度和执行的单位

​ 4. 多进程: 在操作系统中能同时运行多个任务 (程序)

​ 5. 多线程: 在同一应用程序中有多个顺序流同时执行。

​ 6. 线程是进程的一部分,所以线程有的时候被称为轻量级进程。

​ 7. 一个没有线程的进程是可以被看作单线程的,如果一个进程内拥有多个线程,进程的执行过程不是一条线 (线程) 的,而是多条线 (线程) 共同完成的。

​ 8. 系统在运行的时候会为每个进程分配不同的内存区域,但是不会为线程分配内存 (线程所使用的资源是它所属的进程的资源),线程组只能共享资源。那就是说,除了 CPU 之外 (线程在运行的时候要占用 CPU 资源),计算机内部的软硬件资源的分配与线程无关,线程只能共享它所属进程的资源

四、进程与程序的区别

程序是一组指令的集合,它是静态的实体,没有执行的含义。而进程是一个动态的实体,有自己的生命周期。一般说来,一个进程肯定与一个程序相对应,并且只有一个,但是一个程序可以有多个进程,或者一个进程都没有。除此之外,进程还有并发性交往性。简单地说,进程是程序的一部分,程序运行的时候会产生进程

五、通过继承 Thread 类实现多线程

继承 Thread 类实现多线程的步骤:

​ 1. 在 Java 中负责实现线程功能的类是 java.lang.Thread 类。

​ 2. 可以通过创建 Thread 的实例来创建新的线程。

​ 3. 每个线程都是通过某个特定的 Thread 对象所对应的方法 run() 来完成其操作的,方法 run() 称为线程体。

​ 4. 通过调用 Thread 类的 start() 方法来启动一个线程。

public class TestThread extends Thread {//自定义类继承Thread类
    //run()方法里是线程体
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + ":" + i);//getName()方法是返回线程名称
        }
    }
 
    public static void main(String[] args) {
        TestThread thread1 = new TestThread();//创建线程对象
        thread1.start();//启动线程
        TestThread thread2 = new TestThread();
        thread2.start();
    }
}

 ** 此种方式的缺点:** 如果我们的类已经继承了一个类 (如小程序必须继承自 Applet 类),则无法再继承 Thread 类。

注:两个线程出现的顺序是随机的,不可预测的。

六、通过 Runnable 接口实现多线程

 在开发中,我们应用更多的是通过Runnable 接口实现多线程。这种方式克服了 1 继承 Thread 类实现多线程的缺点,即在实现 Runnable 接口的同时还可以继承某个类。所以实现 Runnable 接口的方式要通用一些。

public class TestThread2 implements Runnable {//自定义类实现Runnable接口;
    //run()方法里是线程体;
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    public static void main(String[] args) {
        //创建线程对象,把实现了Runnable接口的对象作为参数传入;
        Thread thread1 = new Thread(new TestThread2());
        thread1.start();//启动线程;
        Thread thread2 = new Thread(new TestThread2());
        thread2.start();
    }
}

七、线程状态

  一个线程对象在它的生命周期内,需要经历 5 个状态。

▪ 新生状态 (New)

​ 用 new 关键字建立一个线程对象后,该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间,通过调用 start 方法进入就绪状态。

▪ 就绪状态 (Runnable)

​ 处于就绪状态的线程已经具备了运行条件,但是还没有被分配到 CPU,处于“线程就绪队列”,等待系统为其分配 CPU。就绪状态并不是执行状态,当系统选定一个等待执行的 Thread 对象后,它就会进入执行状态。一旦获得 CPU,线程就进入运行状态并自动调用自己的run 方法。有 4 中原因会导致线程进入就绪状态:

​ 1. 新建线程:调用start() 方法,进入就绪状态;

​ 2. 阻塞线程:阻塞解除,进入就绪状态;

​ 3. 运行线程:调用yield() 方法,直接进入就绪状态;

​ 4. 运行线程:JVM 将 CPU 资源从本线程切换到其他线程。

▪ 运行状态 (Running)

​ 在运行状态的线程执行自己 run 方法中的代码,直到调用其他方法而终止或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束,就会被系统给换下来回到就绪状态。也可能由于某些“导致阻塞的事件”而进入阻塞状态

线程调度程序将处于就绪状态的线程设置为当前线程,此时线程就进入了运行状态,开始运行 run 函数当中的代码。

▪ 阻塞状态 (Blocked)

​ 阻塞指的是暂停一个线程的执行等待某个条件发生(如某资源就绪)。有 4 种原因会导致阻塞:

​ 1. 执行 sleep(int millsecond)方法,使当前线程休眠,进入阻塞状态。当指定的时间到了后,线程进入就绪状态

​ 2. 执行 wait() 方法,使当前线程进入阻塞状态。当使用nofity() 方法唤醒这个线程后,它进入就绪状态。

​ 3. 线程运行时,某个操作进入阻塞状态,比如执行IO 流操作(read()/write() 方法本身就是阻塞的方法)。只有当引起该操作阻塞的原因消失后,线程进入就绪状态。

​ 4. join() 线程联合: 当某个线程等待另一个线程执行结束后,才能继续执行时,使用 join() 方法。

▪ 死亡状态 (Terminated)

​ 死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。一个是正常运行的线程完成了它 run() 方法内的全部工作; 另一个是线程被强制终止,如通过执行stop()或 destroy() 方法来终止一个线程( 注:stop()/destroy() 方法已经被 JDK 废弃,不推荐使用)。

​ 当一个线程进入死亡状态以后,就不能再回到其它状态了。

八、终止线程的典型方式

终止线程我们一般不使用 JDK 提供的 stop()/destroy() 方法 (它们本身也被 JDK 废弃了)。通常的做法是提供一个boolean 型的终止变量,当这个变量置为 false,则终止线程的运行。

public class TestThreadCiycle implements Runnable {
    String name;
    boolean live = true;// 标记变量,表示线程是否可中止;
    public TestThreadCiycle(String name) {
        super();
        this.name = name;
    }
    public void run() {
        int i = 0;
        //当live的值是true时,继续线程体;false则结束循环,继而终止线程体;
        while (live) {
            System.out.println(name + (i++));
        }
    }
    public void terminate() {
        live = false;
    }
 
    public static void main(String[] args) {
        TestThreadCiycle ttc = new TestThreadCiycle("线程A:");
        Thread t1 = new Thread(ttc);// 新生状态
        t1.start();// 就绪状态
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程" + i);
        }
        ttc.terminate();//死亡状态
        System.out.println("ttc stop!");
    }
}

d688c3928df24d8996811d15e04b2a53_QQ20190419191135.png

九、暂停线程执行 sleep/yield

暂停线程执行常用的方法有 sleep()和 yield() 方法,这两个方法的区别是:

  1. sleep() 方法:可以让正在运行的线程进入阻塞状态,直到休眠时间满了,进入就绪状态。

  2. yield() 方法:可以让正在运行的线程直接进入就绪状态,让出 CPU 的使用权。

暂停线程的方法 -sleep()

public class TestThreadState {
    public static void main(String[] args) {
        StateThread thread1 = new StateThread();
        thread1.start();
        StateThread thread2 = new StateThread();
        thread2.start();
    }
}
//使用继承方式实现多线程
class StateThread extends Thread {
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName() + ":" + i);
            try {
                Thread.sleep(2000);//调用线程的sleep()方法;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以下图示只是部分结果,运行时可以感受到每条结果输出之前的延迟,是 Thread.sleep(2000) 语句在起作用

5e3000e403b24f69b827d54086b55a00_1495788353203039.png

暂停线程的方法 -yield()

public class TestThreadState {
    public static void main(String[] args) {
        StateThread thread1 = new StateThread();
        thread1.start();
        StateThread thread2 = new StateThread();
        thread2.start();
    }
}
//使用继承方式实现多线程
class StateThread extends Thread {
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName() + ":" + i);
            Thread.yield();//调用线程的yield()方法;
        }
    }
}

以下图示只是部分结果,可以引起线程切换,但运行时没有明显延迟

f27489d31a9241fc96bdf5a18bf11482_1495788423831663.png

十、获取线程基本信息的方法

方法 功能
isAlive() 判断线程是否还活着,即线程是否还未终止
getPriority() 获得线程的优先级数值
setPriority() 设置线程的优先级数值
setName() 给线程一个名字
getName() 取得线程的名字
currentThread() 取得当前正在运行的线程对象,也就是取得自己本身
public class TestThread {
    public static void main(String[] argc) throws Exception {
        Runnable r = new MyThread();
        Thread t = new Thread(r, "Name test");//定义线程对象,并传入参数;
        t.start();//启动线程;
        System.out.println("name is: " + t.getName());//输出线程名称;
        Thread.currentThread().sleep(5000);//线程暂停5分钟;
        System.out.println(t.isAlive());//判断线程还在运行吗?
        System.out.println("over!");
    }
}
class MyThread implements Runnable {
    //线程体;
    public void run() {
        for (int i = 0; i < 10; i++)
            System.out.println(i);
    }
}

运行结果:

name is: Name test
0
1
2
3
4
5
6
7
8
9
false
over!

十一、线程的优先级

  1. 处于就绪状态的线程,会进入“就绪队列”等待 JVM 来挑选。

​ 2. 线程的优先级用数字表示,范围从1 到 10,一个线程的缺省优先级是 5。

​ 3. 使用下列方法获得或设置线程对象的优先级。

​ int getPriority();

​ void setPriority(int newPriority);

​ 注意:优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高的线程后调用优先级低的线程

public class TestThread {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread(), "t1");
        Thread t2 = new Thread(new MyThread(), "t2");
        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}
class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

运行结果:

t1: 0
t1: 1
t1: 2
t1: 3
t1: 4
t1: 5
t1: 6
t2: 0
t2: 1
t2: 2
t2: 3
t1: 7
t2: 4
t2: 5
t2: 6
t2: 7
t2: 8
t2: 9
t1: 8
t1: 9