Java多线程详解

最新推荐文章于 2021-06-10 17:08:49 发布

哈哈哈哈哈基米

最新推荐文章于 2021-06-10 17:08:49 发布

阅读量683

点赞数 3

分类专栏： java 文章标签：多线程 java 编程语言 jvm

本文链接：https://blog.csdn.net/ssH18868325485/article/details/109360633

版权

java 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

Java多线程总结

整理一下老杜的课堂笔记

什么是进程，什么是线程

进程是一个应用程序，一个软件，比如QQ，微信，英雄联盟都是一个进程。线程是一个进程中的执行场景/执行单元，一个进程可以启动多个线程。比如火车站售票窗口，火车站是一个进程，每个售票窗口都是一个线程。

对于java程序来说，当在DOS命令窗口中输入：
java HelloWorld 回车之后。
会先启动JVM，而JVM就是一个进程。
JVM再启动一个主线程调用main方法。
同时再启动一个垃圾回收线程负责看护，回收垃圾。
最起码，现在的java程序中至少有两个线程并发，
一个是垃圾回收线程，一个是执行main方法的主线程。

线程和进程的关系：
进程A和进程B的内存独立不共享。魔兽游戏是一个进程,酷狗音乐是一个进程。这两个进程是独立的，不共享资源。

线程A和线程B呢？
        在java语言中：
        线程A和线程B，堆内存和方法区内存共享。
        但是栈内存独立，一个线程一个栈。

假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，
互不干扰，各自执行各自的，这就是多线程并发。

火车站，可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。
所以多线程并发可以提高效率。
java中之所以有多线程机制，目的就是为了提高程序的处理效率。

实现线程的3种方式

第一种方式： 编写一个类，直接继承java.lang.Thread，重写run方法。

public class Test01 {
    public static void main(String[] args) {
        Thread myThread = new MyThread();
        myThread.start();//启动线程
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i =0;i<10;i++){
            System.out.println(i);
        }
    }
}

start()方法的作用：启动一个分支线程，在JVM种开辟一个新的栈空间，这段代码瞬间完成，线程启动成功之后会自动调用run()方法，run()方法在分支栈的底部，run()方法和main()方法是平级的。
注：直接在main()方法种调用run()方法是不会启动线程的，也不会分配新的栈空间，只是在主栈中运行run()方法而已。

第二种方式： 编写一个类，实现java.lang.Runnable接口，实现run方法。

public class Test01 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();//这只是一个可运行的对象，还不是一个线程
        Thread t = new Thread(myThread);//将Runnable传入
        t.start();//启动线程
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            System.out.println(i);
        }
    }
}

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。

第三种方式： 实现Callable接口。（JDK8新特性。）
       这种方式实现的线程可以获取线程的返回值。
       之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
       系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么能拿到这个执行结果呢？
使用第三种方式：实现Callable接口方式。

public class Test01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread myThread = new MyThread();
        FutureTask f = new FutureTask(myThread);//创建未来任务类对象，JUC包下的
        Thread t = new Thread(f);//把未来任务类对象传入
        t.start();//启动线程
        Object res = f.get();//该方法能获取返回值
        System.out.println(res);//45
    }
}
class MyThread implements Callable {

    @Override
    public Object call() throws Exception {
        int res = 0;
        for (int i = 0;i<10;i++){
            res += i;
        }
        return res;
    }
}

注意：get()方法在主线程运行，会使得主线程受阻，get()方法是用来获取另一个线程的返回值的，但是另一个线程的执行可能需要过长的时间。

线程的生命周期

上老杜的图：在这里插入图片描述

几个常用的方法

1.获取当前线程对象

Thread t = Thread.currentThread();

2.获取线程对象的名字

Thread t = Thread.currentThread();
String name = t.getName();

3.修改线程对象的名字

Thread t = Thread.currentThread();
t.setName("t1线程");

4.isAlive(),判断当前线程是否处于活动状态（线程已启动并且尚未终止）。

		SubThread subThread = new SubThread();
        System.out.println(subThread.isAlive()); //false
        subThread.start();
        System.out.println(subThread.isAlive());//这里可能true 可能 false
        Thread.sleep(1000);
        System.out.println(subThread.isAlive());//false

5.sleep()，让当前线程进入休眠，进入阻塞状态，放弃占有的时间片

Thread.sleep(1000);//睡眠一秒

面试题：问下面程序是否能让t线程进入睡眠？

public class Test01 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.setName("t");
        t.start();

        try {
            t.sleep(1000);//是否能让t线程进入休眠
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            System.out.println(i);
        }
    }
}

答：不会，sleep()是静态方法，只会让当前线程进入休眠。

6.终止线程的休眠。interrupt()方法。注意，这个方法依靠的是java的异常处理机制，这个方法执行的时候会让slee()报异常，使程序进入catch语句块，使得sleep()方法结束。

public class Test01 {
    public static void main(String[] args) {

        Thread t = new MyThread();
        t.start();
        t.interrupt();//终止休眠

    }
}
class MyThread extends Thread {

    @Override
    public void run() {
        try {
            Thread.sleep(1000*60*60*24*365);//休眠一年
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0;i<10;i++){
            System.out.println(i);
        }
    }
}

该方法也可以用来中断线程，单独使用该方法仅仅是在当前线程打一个中断标志，并不是真正的停止线程。
我们需要用一下的方式来中断线程
在这里插入图片描述 *** 使用该方法也可以让线程中断wait(),并抛出异常。

7.getId(); thread.getId()可以获得线程的唯一标识。
注意：某个编号的线程运行结束之后，该编号可能被后续创建的线程使用。

	Thread t = new MyThread();
    System.out.println(t.getId()); //获取线程编号

强行终止一个线程

stop()方法，但是这个方法容易丢失数据，不建议使用。已经过时了。

Thread t = new MyThread();
t.start();
t.stop();//强行终止

合理终止一个线程的执行：打一个布尔标记就可以了。

public class Test01 {
    public static void main(String[] args) throws InterruptedException {

        MyThread m = new MyThread();
        Thread t = new Thread(m);
        t.start();
        Thread.sleep(1000*5);//模拟5秒后终止线程
        m.run = false;//终止线程

    }
}
class MyThread implements Runnable {
    boolean run = true;
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            if (run){
                System.out.println(i);
            }else {
                //可以在return之前保存数据
                return;
            }
        }

    }
}

线程的调度（了解内容）

1、常见的线程调度模型有哪些？

	抢占式调度模型：
		那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
		java采用的就是抢占式调度模型。

	均分式调度模型：
		平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
		平均分配，一切平等。
		有一些编程语言，线程调度模型采用的是这种方式。

2、java中提供了哪些方法是和线程调度有关系的呢？
        实例方法：
        void setPriority(int newPriority) 设置线程的优先级
        int getPriority() 获取线程优先级
        最低优先级1
        默认优先级是5
        最高优先级10
        优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）并不是优先级高的抢到时间片的几率大。
线程的优先级具有继承性，在A线程中创建了B线程，则B线程的优先级与A线程一样。

t.setPriority(10);//设置优先级为10
int i = t.getPriority();//获取优先级

        静态方法：
        static void yield() 让位方法
        暂停当前正在执行的线程对象，并执行其他线程
        yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
        yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
        注意：在回到就绪之后，有可能还会再次抢到。

Thread.yield();

实例方法：
void join() 合并线程：这个方法不是栈的合并，而是栈互相之间发生了等待。

MyThread m = new MyThread();
        Thread t = new Thread(m);
        t.start();
        t.join();//当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
        for (int i = 0;i<10;i++){
            System.out.println("main");
        }

多线程并发环境下，数据的安全问题

1、什么时候数据在多线程并发的环境下会存在安全问题呢？
         三个条件：
                条件1：多线程并发。
                条件2：有共享数据。
                条件3：共享数据有修改的行为。

满足以上3个条件之后，就会存在线程安全问题。

2、怎么解决线程安全问题呢？
        当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
        线程排队执行。（不能并发）。
        用排队执行解决线程安全问题。
        这种机制被称为：线程同步机制。

专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。

3、怎么解决线程安全问题呀？
使用“线程同步机制”。

线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

4、同步编程模型和异步编程模型
异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，
谁也不需要等谁，这种编程模型叫做：异步编程模型。
其实就是：多线程并发（效率较高。）

异步就是并发。

同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行
结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，
两个线程之间发生了等待关系，这就是同步编程模型。
效率较低。线程排队执行。

同步就是排队。

5、Java中有三大变量？【重要的内容。】

实例变量：在堆中。

静态变量：在方法区。

局部变量：在栈中。

以上三大变量中：
局部变量永远都不会存在线程安全问题。
因为局部变量不共享。（一个线程一个栈。）
局部变量在栈中。所以局部变量永远都不会共享。

实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

6.线程同步机制的语法（三种）：

		第一种：同步代码块，找的是对象锁
			灵活
			synchronized(线程共享对象){
				同步代码块;
			}

		第二种：在实例方法上使用synchronized，找的是对象锁
			表示共享对象一定是this
			并且同步代码块是整个方法体。
		
		第三种：在静态方法上使用synchronized
			表示找类锁。
			类锁永远只有1把。
			就算创建了100个对象，那类锁也只有一把。
		
		对象锁：1个对象1把锁，100个对象100把锁。
			（我们经常会使用this或者自定义常量作为对象锁。）
		类锁：100个对象，也可能只是1把类锁。
		注：如果线程在执行过程中出现异常，会讲锁释放，后面等待的线程
		   就能拿到锁执行代码。

在这里插入图片描述

死锁：
在这里插入图片描述

public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        Object o2 = new Object();
        Thread t1 = new Thread(new MyThread(o1,o2));
        Thread t2 = new Thread(new MyThread2(o1,o2));
        t1.start();
        t2.start();
    }
}
class MyThread implements Runnable {

    Object o1;
    Object o2;

    public MyThread(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    public void run() {
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){

            }
        }
    }
}
class MyThread2 implements Runnable{
    Object o1;
    Object o2;

    public MyThread2(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){

            }
        }
    }
}

我们以后开发中应该怎么解决线程安全问题？

是一上来就选择线程同步吗？synchronized
	不是，synchronized会让程序的执行效率降低，用户体验不好。
	系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
	线程同步机制。

第一种方案：尽量使用局部变量代替“实例变量和静态变量”。

第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，
对象不共享，就没有数据安全问题了。）

第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候
就只能选择synchronized了。线程同步机制。

守护线程

java语言中线程分为两大类：
	一类是：用户线程
	一类是：守护线程（后台线程）
	其中具有代表性的就是：垃圾回收线程（守护线程）。

守护线程的特点：
	一般守护线程是一个死循环，所有的用户线程只要结束，
	守护线程自动结束。

注意：主线程main方法是一个用户线程。

守护线程用在什么地方呢？
	每天00:00的时候系统数据自动备份。
	这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
	一直在那里看着，没到00:00的时候就备份一次。所有的用户线程
	如果结束了，守护线程自动退出，没有必要进行数据备份了。

t.setDaemon(true);//启动线程之前，用该代码能将线程设置为守护线程
t.start();

定时器

定时器的作用：
	间隔特定的时间，执行特定的程序。

	每周要进行银行账户的总账操作。
	每天要进行数据的备份操作。

	在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
	那么在java中其实可以采用多种方式实现：
		
		可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行
		任务。这种方式是最原始的定时器。（比较low）

		在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。schedule()方法能完成定时器。
		不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持
		定时任务的。

		在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
		这个框架只要进行简单的配置，就可以完成定时器的任务。

public class Test01 {
    public static void main(String[] args) throws InterruptedException, ParseException {
        Timer timer = new Timer();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2020-10-29 20:00:00");
        timer.schedule(new LogTimerTask(),firstTime,1000*5);//5秒执行一次
    }
}
class LogTimerTask extends TimerTask{

    @Override
    public void run() {
        System.out.println(1);
        //编写需要进行的任务就行了
    }
}

关于Object类中的wait和notify方法。（生产者和消费者模式！）

这两个方法需要放在同步代码块中，否则会产生IlleaglMonitorStateException异常

第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象
都有的方法，因为这两个方式是Object类中自带的。
	wait方法和notify方法不是通过线程对象调用，
	不是这样的：t.wait()，也不是这样的：t.notify()..不对。

第二：wait()方法作用？
	Object o = new Object();
	o.wait();

	表示：
		让正在o对象上活动的线程进入等待状态，无期限等待，
		直到被唤醒为止。
		o.wait();方法的调用，会让“当前线程（正在o对象上
		活动的线程）”进入等待状态。

第三：notify()方法作用？
	Object o = new Object();
	o.notify();

	表示：
		唤醒正在o对象上等待的线程。
	
	还有一个notifyAll()方法：
		这个方法是唤醒o对象上处于等待的所有线程。

使用 wait和notify方法实现生产者和消费者模式
在这里插入图片描述

public class Test01 {
    public static void main(String[] args) {
        List list = new ArrayList();
        Thread producer = new Producer(list);
        Thread consumer = new Consumer(list);
        producer.start();
        consumer.start();
    }
}

class Producer extends Thread{
    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true){
            synchronized (list){
                if (list.size()>0){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    list.add(new Object());
                    System.out.println("生产一个");
                    list.notify();
                }
            }

        }
    }
}

class Consumer extends Thread{
    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true){
            synchronized (list){
                if (list.size()==0){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    list.remove(0);
                    System.out.println("消费一个");
                    list.notify();
                }
            }
        }
    }
}