Java多线程编程笔记1：线程简介-优快云博客

本文深入探讨Java多线程编程关键技术，包括线程的启动、暂停、停止、优先级及同步异步概念，讲解进程与线程的区别，多线程的优势，以及线程安全问题的解决方案。

Thread类关键技术点：

线程的启动
如何使线程暂停
如何使线程停止
线程的优先级
线程安全

进程和线程

进程

进程是操作系统结构的基础；是一次程序的执行；是一个程序及其数据在处理机上顺序执行时所发生的活动；是程序在一个数据集合上运行的过程，它是从系统进行资源分配和调度的一个独立单位。

线程

线程是一个比进程更小的执行单位，可以理解成是在进程中独立运行的子任务。一个进程在执行过程中可以产生多个线程，同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间做切换时，负担比进程小得多。

多线程

多线程就是指多个线程同时运行或交替运行。单核CPU是顺序执行，也即交替运行。多核CPU，因为每个CPU有自己的运算器，所以在多个CPU可以同时运行。

为什么要使用多线程

更多的处理器核心，使得多线程能分配到多个处理器核心，减少了程序的处理时间，提升了效率
更快的响应时间：将数据一致性不强的操作派发给不同的线程，从而缩短了响应时间
更好的编程模型

创建线程

在Java中，实现多线程编程的方式主要有两种，一种是继承Thread类，一种是实现Runnable接口。

在Java源码中，Thread类实现了Runnable接口，它们之间具有多态关系。使用这两种方式创建的线程在工作时性质是一样的，没有本质区别。

继承Thread创建线程

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread");
    }
}
复制代码

测试：

public class TestThread {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        t1.start();
        System.out.println("运行结束");
    }
}
复制代码

输出结果为：

运行结束
MyThread
复制代码

可以看出，在多线程编程中，代码的运行结果与代码执行顺序或者调用顺序无关。

同时，线程是一个子任务，CPU以随机的时间来调用线程中的run方法。如下代码所示：

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                int time = (int) (Math.random() * 1000);
                Thread.sleep(time);
                System.out.println("run:"+Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

测试：

public class TestThread {
    public static void main(String[] args) {
        try{
            MyThread thread=new MyThread();
            thread.setName("MyThread");
            thread.start();
            for(int i=0;i<5;i++){
                int time = (int) (Math.random() * 1000);
                Thread.sleep(time);
                System.out.println("main:"+Thread.currentThread().getName());
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

输出结果：

run:MyThread
run:MyThread
main:main
run:MyThread
main:main
run:MyThread
main:main
run:MyThread
main:main
main:main
复制代码

start()方法通知此线程已经准备就绪，等待调用线程对象中的run()方法。这个过程就是让系统安排一个时间来调用Thread中的run()方法。但是如果调用thread.run()就不是异步执行了，而是同步，因为这是由main()函数调用的，等run()方法中的代码结束后，才可以执行后边的代码。另外，执行start()方法的顺序不代表线程启动的顺序。

实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running");
    }
}
复制代码

测试：

public class TestThread {
    public static void main(String[] args) {
        test2();
    }

    public static void test2() {
        Thread t=new Thread(new MyRunnable());
        t.start();
        System.out.println("运行结束");
    }
}
复制代码

运行结果：

运行结束
MyRunnable is running
复制代码

说明与继承Thread实现并没有什么不同。但是由于Java是单继承，继承Thread类的方式由局限性。

实例变量与线程安全

自定义线程类中的实例变量针对其他线程可以共享或不共享。

不共享数据的情况

public class MyThread extends Thread {
    private int count=3;
    public MyThread(String name){
        super();
        this.setName(name);
    }
    @Override
    public void run() {
        super.run();
        while(count>0){
            count--;
            System.out.println(Thread.currentThread().getName()+" "+count);
        }
    }
}
复制代码

测试代码：

public class TestThread {
    public static void main(String[] args) {
        MyThread t1=new MyThread("t1");
        MyThread t2=new MyThread("t2");
        MyThread t3=new MyThread("t3");
        t1.start();
        t2.start();
        t3.start();
    }
}
复制代码

输出结果：

t1 2
t3 2
t3 1
t3 0
t2 2
t2 1
t2 0
t1 1
t1 0
复制代码

说明：创建了多个线程，每个线程都有自己的count变量，变量不共享。不存在多个线程访问同一个实例变量的情况。

共享数据的情况

共享数据就是多个线程访问同一个变量。

public class MyThread extends Thread {
    private int count = 5;

    @Override
    public void run() {
        super.run();
        count--;
        System.out.println(Thread.currentThread().getName()+" "+count);
    }
}
复制代码

测试代码：

public class TestThread {
    public static void main(String[] args) {
    //将同一个Thread类的对象传入，将t.run()交由其他的线程调用
        MyThread t=new MyThread();
        Thread t1=new Thread(t,"t1");
        Thread t2=new Thread(t,"t2");
        Thread t3=new Thread(t,"t3");
        Thread t4=new Thread(t,"t4");
        Thread t5=new Thread(t,"t5");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}
复制代码

同上，输出结果：

t2 3
t3 2
t1 3
t4 1
t5 0
复制代码

可以看出出现了错误，多个线程同时对count进行处理，产生了“非线程安全”问题。原因是在jvm中，count--的操作分为三步：1.取得原有count；计算count-1；对count赋值。

需要在线程之间同步，按顺序排队的方式进行减一操作。使用synchronized关键字修改后：

public class MyThread extends Thread {
    private int count = 5;

    @Override
    synchronized public void run() {
        super.run();
        count--;
        System.out.println(Thread.currentThread().getName()+" "+count);
    }
}
复制代码

结果为：

t1 4
t4 3
t3 2
t2 1
t5 0
复制代码

此时结果正常。在run芳芳前加入synchronized关键字，使得多个线程以排队方式处理。经过加锁的这段代码成为“互斥区”或“临界区”。

常用方法

CurrentThread()：返回代码段正在被哪个线程调用。
isAlive():判断线程是否处于活动状态。活动状态是指线程已经启动且尚未终止，处于正在运行或准备运行的状态。
sleep():使当前正在执行的线程以特定的毫秒数“休眠”，也即暂停执行。当前正在执行的线程指的是this.currentThread()返回的线程。
getId():返回线程的唯一标识符
yield():放弃当前的CPU资源，将它让给其他任务去占用CPU执行，但是放弃的时长不确定，可能刚刚放弃，马上又获得。

停止线程的相关方法

在Java中有以下三种方法可以终止正在运行的线程：

使用退出标志，使线程正常退出，也即当run方法完成后线程终止。
使用stop方法强行终止线程，已弃用的方法。
使用interrupt方法中断线程。

在Thread类中，提供了两种方法判断线程的状态是否停止：

this.interrupted():这是一个static方法，测试当前线程是否已经中断，当前线程指的是运行this.interrupted()方法的线程。同时需要注意，该方法执行后具有将状态标志置清除为false的功能。
this.isInterrupted():测试线程Thread对象是否已经是中断状态，但是不清除状态标志。

interrupt()方法用来停止线程，但是该方法的使用效果是仅仅在当前线程中打了一个停止的标记，并不是真的停止线程。

可以使用异常的方法停止线程：

public class MyThread extends Thread {

    @Override
    public void run() {
        try {
            for(int i=0;i<50000;i++){
                if(this.interrupted()){
                    System.out.println("线程到达停止状态，退出");
                    throw new InterruptedException();
                }
                System.out.println("i: "+(i+1));
            }
        } catch (InterruptedException e) {
            System.out.println("在run方法的catch块中");
            e.printStackTrace();
        }
    }
}

复制代码

测试代码：

public class TestThread {
    public static void main(String[] args) {
        try {
            MyThread t=new MyThread();
            t.start();
            Thread.sleep(200);
            t.interrupt();
        } catch (InterruptedException e) {
            System.out.println("在main的catch块");
            e.printStackTrace();
        }
    }
}
复制代码

输出结果：

i: 24537
i: 24538
i: 24539
i: 24540
i: 24541
java.lang.InterruptedException
	at ch01.multithread.MyThread.run(MyThread.java:11)
线程到达停止状态，退出
在run方法的catch块中
复制代码

stop()方法已经被作废，首先可能使得一些请理性的工作得不到完成；还会对锁定的对象进行了“解锁”，导致数据得不到同步的处理，出现了数据不一致的问题。

使用return停止线程

使用interrupt()与return结合使用也能实现停止线程的效果。只需把上述的抛出异常的语句改为return即可。但是建议使用抛出异常的方法来实现线程的停止。