JavaEE_多线程(一)

1. 为啥要有线程

1. 为了并发编程,随着多核CPU的发展,多线程称为刚需
2. 多进程虽然也能实现并发编程的效果,但是进程的创建和销毁太重量了

1.1 线程是什么

线程: 一个线程就是一个执行流,每个线程之间都可以按照自己的顺序执行自己的代码,多个线程可以分别执行多份代码
引入多个进程是为了实现并发编程,多进程实现并发编程效果也很好，但是多进程有明显的缺点，进程太重量，效率不高
线程也叫轻量级进程，创建线程，销毁线程，调度线程都比进程要更快

1.2 进程和线程的区别

1. 进程是包含线程的,一个进程里可以有一个线程,也可以有多个线程
2. 进程和线程都可以作为并发编程的条件,但是线程比进程更高效
3. 同一个进程和线程之间,公用一份资源(内存+硬盘),省去了申请资源的开销
4. 进程和进程之间,具有独立性,一个进程挂了,并不会影响到其他进程,但是在同一个进程内的线程和线程之间,可能会互相影响
5. 进程是资源分配的基本单位,线程是调度执行的基本单位

1.3 Java如何进行多线程编程

线程是操作系统的概念,操作系统提供了一些API,可以操作线程,Java针对上述系统API进行了封装(跨平台),我们只需要掌握这一套API即可

2 使用线程

2.1 创建线程

方法一: 继承Thread类

1. 创建一个类继承Thread,重写run方法
2. 创建类的实例
3. 调用start方法启动线程

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello");
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.start();
    }
}

start和run都是Thread的成员,run只描述了线程的入口(线程要做什么任务),start 则是真正调用系统API,在系统中创建出线程,让线程在调用API

方法2: 实现Runable 接口

1. 写一个类实现Runnable接口,并重写run方法
2. 创建Thread类的实例,调用Thread的构造方法时将MyRunnable对象作为参数
3. 调用start方法

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello");
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();
    }
}

方法3:匿名内部类创建Thread子类对象

public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello");
                }
            }
        };
        t.start();
    }

方法4: 使用匿名内部类创建Runnable子类对象

    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello");
                }
            }
        });
        t.start();
    }

方法5:lambda表达式创建Runnable子类对象(最推荐的写法)

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
           while (true) {
               System.out.println("hello");
           }
        });
        t.start();
    }

除了这5种方法外,还有一些其他方法,以后再介绍

2.2 Thread类的几个常见方法和属性

Thread类是JVM用来管理线程的一个类,每一个线程都有唯一的Thread对象与之关联,Thread类对象就是用来描述一个线程执行流的

2.2.1 Thread常见构造方法

    public static void main(String[] args) {
        // Thread() 创建线程对象
        // Thread(Runnable t) 使用Runnable对象创建线程
        // Thread(String name) 创建线程并命名
        // Thread(Runnable t, String name) 
        // 使用 Runnable 对象创建线程对象，并命名
        Thread t = new Thread(() -> {
           while (true) {
               System.out.println("hello");
           }
        },"新线程");
    }

name并不会影响到线程运行,只是单纯的取了个名字,方便我们后续的调试

2.2.2 Thread常见属性

1. ID :ID是线程的唯一标识,不同的线程不会重复. 获取方法是getid()
2. 名称: 名称是各种调试工具会用到 获取方法是getName()
3. 状态: 状态表示线程当前所处于的一个状态,下面会进一步说明 getState()
4. 优先级:优先级影响到的是系统微观上的调度,宏观上我们很那察觉,我们仅需要知道有这个东西就可以了 getPriority()
5. 是否后台线程: 默认情况下我们创建的是前台线程 isDaemon()
6. 是否存活: run方法是否运行结束了 isAlive()

start方法和run方法的区别
start方法的内部,会调用系统的API,来在系统内核中创建出线程
run方法,就只是单纯的描述了该线程要执行啥内容(会在start创建好之后自动被调用)
二者看起来效果是相似的,本质上的差别是 是否在系统内核中创建出新的线程

2.2.3 常见其他方法

public static Thread currentThread(): 返回当前线程对象的引用
public static void sleep(long millis): 休眠当前线程

2.3 终止一个线程

启动线程很简单,只需要调用start方法即可,那么终止线程呢?

在Java中,要让一个线程停止运行(销毁),做法是比较唯一的,就是想办法让run方法尽快执行结束
目前常用的有两种方法

2.3.1 通过共享的标记位来进行沟通

可以自己手动设置一个标志位(boolean类型的变量),来控制线程是否要执行结束

public class Demo8 {
    private static boolean isQuit = false;

    public static void main(String[] args) throws InterruptedException {
       // boolean isQuit = false;
        Thread t = new Thread(() -> {
           while (!isQuit) {
               System.out.println("线程工作中");
           }
            System.out.println("线程工作完毕");
        });

        t.start();
        Thread.sleep(5000);

        isQuit = true;
        // 这里改变了isQuit
        System.out.println("设置 isQuit为true");
    }
}

番外: 为什么isQuit要写成成员变量,而不能写成main方法的局部变量呢?
lambda表达式有一个语法规则,是变量捕获
在Java中,变量捕获语法有一个限制条件,必须捕获一个final或者实际上是final的变量(变量虽然没有使用final,但是实际上没发生修改)

2.3.2 调用interrupt()方法来通知

public void interrupt(): 设置标志位,中断对象关联的线程,如果线程正在阻塞,则会以异常的方式通知
public boolea isInterrupted(): 判断当前对象关联的线程的标志位是否设置,调用后不清除标志位

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted())
            // 在Thread内部,其实有一个现成的标志位,
            // 可以用来判定当前的循环是否要结束
            {
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });
        t.start();

        Thread.sleep(5000);
        System.out.println("让t线程终止");
        t.interrupt();
    }

2.4 等待一个线程

public void join(): 等待线程结束
public void join(long m): 等待线程结束,最多等m毫秒

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();


        System.out.println("main线程等待中");
        t.join();
        // 一旦调用join方法,主线程就会阻塞,此时t线程会继续执行
        // 一直到t线程执行结束了,join才会解除阻塞
        System.out.println("main线程等待结束");
    }

join其他细节后期再讲