多线程总结

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量84 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40458861/article/details/112689264
版权

多线程总结

多线程描述

一个程序在执行的过程中，可以产生多个线程，每个线程有自己的执行路径，线程是在基于进程之上划分的，没有进程就没有线程，进程相当于一个应用程序，有独立的内存空间。每个线程有自己的产生，存在，消亡的过程。线程有自己独立的栈空间和共享的堆空间。

  • 继承Thread
  • 实现Runnable

线程的调度

分时调度

  • 所有线程轮流使用CPU的使用权，平分每个线程的CPU占用时间

抢占式调度

  • 线程执行优先级相同的情况下，CPU会随机选择执行线程，优先级高的线程抢到CPU时间片的概率会大很多。JAVA使用的就是抢占式调度。

同步和异步

同步的意思就是多个线程之间排队执行，当执行中的线程执行完的时候，才会执行下一个线程，这种机制效率低，但安全。
异步就是多个线程之间同时执行，这种情况下，数据是不安全的。但是效率高。

并发与并行

并发就是在一个时间段内发生了多个事件
并行就是多个事件同时发生

多线程实现

继承Thread
通过实例化继承了Thread的子类来创建这个线程，调用start()方法来启动这个线程。

// MyThread.java
public class MyThread extends Thread {

    @Override
    public void run() {
        super.run();
        // 这里是线程要执行的代码块
    }
}

// Main.java
public class Main {
	
	public static void main(String[] args) {
		// 创建一个线程
		MyThread myThread = new MyThread();
		// 启动线程
		myThread.start();
	}

}

实现Runnable接口
声明一个类实现Runnable接口，然后实现run()方法。在创建Thread时传入这个类的实例。然后调用start()启动线程。

// MyRunnable.java
public class MyRunnable implements Runnable {

    @Override
    public void run() {
        // 这里是线程执行的代码块
    }
}

// Main.java
public class Main {
	
	public static void main(String[] args) {
		// 实例化MyRunnable
		MyRunnable myRunnable = new MyRunnable();
		// 创建一个匿名Thread并传入myRunnable然后调用start()启动
		new Thread(myRunnable).start();
	}

}

获取和设置线程的名称

每一个线程都有一个名称，多个线程名称可重复。在创建线程时为传入名称会自动生成一个名称。

Thread.currentThread() 是返回当前线程对象的引用

// 获取线程名称
Thread.currentThread().getName();
// 设置线程名称
Thread.currentThread().setName("设置的名称");

线程休眠

使当前正在执行的线程进入休眠状态（暂停执行）。

Thread.sleep(1000);
// 休眠1000毫秒，参数为long类型
Thread.sleep(1000, 1000);
// 休眠1000毫秒加1000纳秒, 参数二为int类型

线程阻塞

线程阻塞就是所有比较耗时间的操作都可以理解为线程阻塞。Thread.sleep()和Thread.wait()都是线程阻塞的一种情况。

线程中断

一个线程它是否要结束由它自己决定。也可以由外部调用其interrupt()方法告诉线程你该结束了，但具体要不要中断线程，还是要看线程内部是怎么实现的。

调用interrupt()的几种情况:

  1. 若该线程调用了wait(), wait(long), wait(long, int)或join(long), join(long, int), sleep(long), sleep(long, int)，那这个时候将会清除其中断状态并收到InterruptedException异常。
  2. 若在InterruptibleChannel上的IO操作中终止该线程，则通道将关闭，线程的中断状态被清除并收到ClosedByInterruptException异常。
  3. 如果该线程在Selector中被阻塞，则线程的中断状态将被设置，它将立即从选择操作返回，可能具有非零值，就像调用选择器的wakeup方法一样。

如果以前的条件都不成立，则将设置该线程的中断状态。中断不活动的线程不会产生任何影响。

守护线程

当没有一个用户线程，仅剩下守护线程的时候。JVM虚拟机将退出。

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        
    }
});
thread.setDaemon(true);		// 设置为守护线程
thread.setDaemon(false);	// 设置为用户线程

// 判断当前线程是否为守护线程
thread.isDaemon();

线程安全

同步代码块

// 格式			synchronized(锁对象) {}  注：锁对象可以是任何对象，如果多个线程之间不是同一个锁对象，则不能实现同步锁。
// 如：
class Ticket implements Runnable {

	private int count = 10;
	// 锁对象
	private final Object i = new Object();

    @Override
    public void run() {
        while (true) {
        // 给这段代码加锁，当有线程执行当时候锁上，其他线程等待，执行完毕后，哪个线程抢到哪个线程执行。
            synchronized(i) {
                if (count > 0) {
                    System.out.println(Thread.currentThread().getName() + "开始出票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println("剩余" + count);
                } else
                    break;
            }
        }
    }
}

同步方法

class Ticket implements Runnable {

	private int count = 10;

	@Override
	public void run() {
	    while (true) {
	        if (!sale())
	            break;
	    }
	}

	private synchronized boolean sale() {
	    if (count > 0) {
	        System.out.println(Thread.currentThread().getName() + "开始出票");
	        try {
	            Thread.sleep(1000);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	        count--;
	        System.out.println("剩余" + count);
	        return true;
	    }
	    return false;
	}
}

显式锁

class Ticket implements Runnable {

	private int count = 10;
	// 显示锁对象
	private final Lock lock = new ReentrantLock();
	
	@Override
	public void run() {
	    while (true) {
	    	// 获得锁
	        lock.lock();
	        if (count > 0) {
	            System.out.println(Thread.currentThread().getName() + "开始出票");
	            try {
	                Thread.sleep(1000);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	            count--;
	            System.out.println("剩余" + count);
	        } else {
	            break;
	        }
	        // 释放锁
	        lock.unlock();
	    }
	}
	}

其中，synchronized是隐式锁，Lock是显示锁，显示锁和隐式锁的区别就在于需不需要使用者手动获取锁和释放锁。隐式锁在使用完后系统会自动释放锁，非逻辑问题不会出现死锁，而显示锁如果用完了没有释放锁，会导致出现死锁的情况。

公平锁和非公平锁

在使用显示锁的时候可以传一个参数fair，true的时候就是公平锁，false就是不公平锁，公平锁就是多个线程排队执行，非公平锁就是执行完后谁抢到谁执行。

// 上面三种同步锁默认都是非公平锁
Lock lock = new ReentrantLock(true)		// 公平锁
Lock lock = new ReentrantLock(false)		// 非公平锁

多线程通信问题

public class Main {

    public static void main(String[] args) {
        Food food = new Food();
        Thread cook = new Thread(new Cook(food));
        Thread waiter = new Thread(new Waiter(food));
        cook.start();
        waiter.start();
    }

    static class Cook implements Runnable {

        private final Food food;

        public Cook(Food food) {
            this.food = food;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    if (i % 2 == 0) {
                        food.set("红烧茄子", "美味的");
                    } else {
                        food.set("奥利给", "难吃的");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Waiter implements Runnable {

        private final Food food;

        public Waiter(Food food) {
            this.food = food;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    food.get();
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Food {
        private String name;
        private String taste;

        public synchronized void set(String name, String taste) throws InterruptedException {
            this.name = name;
            Thread.sleep(100);
            this.taste = taste;
            try {
                notifyAll();
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public synchronized void get() {
            System.out.printf("菜名：%s，味道%s\n", name, taste);

            try {
                notifyAll();
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

线程的状态

线程状态。 线程可以处于以下状态之一：

  • NEW
    尚未启动的线程处于此状态。

  • RUNNABLE
    在Java虚拟机中执行的线程处于此状态。

  • BLOCKED
    被阻塞等待监视器锁定的线程处于此状态。

  • WAITING
    无限期等待另一个线程执行特定操作的线程处于此状态。

  • TIMED_WAITING
    正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。

  • TERMINATED
    已退出的线程处于此状态。
    注：图片出处：https://blog.csdn.net/pange1991

Callable

这个接口类似于Runnable， 带有返回值结果。此接口有一个方法V call(), 计算结果，返回V类型， 如果无法执行，抛出异常。

Callable和Runnable的相同点

  • 都是接口
  • 都可以编写多线程程序
  • 都采用Thread.start()启动线程

不同点

  • call()方法能够抛出异常，run()不能抛出异常
  • call()有返回值，run()没有返回值

获取Callable的返回值

  • V get() 等待线程结束获取返回值
  • V get(long timeout, TimeUnit unit) 最多等待给定的时间。

实例

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(myCallable);
        new Thread(task).start();
        // task.isDone() 用于判断线程是否执行完毕
        System.out.printf("线程是否执行完毕: %s%n", task.isDone() ? "是" : "否");
        int result = task.get();    // 这里阻塞了线程获取返回值
        System.out.printf("线程是否执行完毕: %s%n", task.isDone() ? "是" : "否");
        System.out.printf("返回的结果是: %d%n", result);
        System.out.println("程序结束");
        // 还可以使用task.cancel()来停止线程
    }

    static class MyCallable implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return 100;
        }
    }

}

线程池

如果并发的线程数量很多，并且每一个线程是执行一个时间很短的任务就结束了。这样频繁创建线程就会大大降低效率，因为频繁的创建线程和销毁线程需要时间。线程池就是一个容纳多个线程的容器，池中的线程可以重复使用，省去了频繁创建线程对象的操作，节省来大量的时间和资源。

线程池的好处

  1. 降低资源消耗
  2. 提高响应速度
  3. 提高线程的可管理性

JAVA中的四种线程池

  • 缓存线程池
  • 定长线程池
  • 单线程线程池
  • 周期性任务定长线程池

缓存线程池

/**
缓存线程池. (长度无限制) 执行流程:
1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在,则创建线程 并放入线程池, 然后使用
*/
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        // 前面缓存了三个线程
        Thread.sleep(1000);
        // 休眠一秒让前面的线程执行完毕
        // 再来添加一个任务就会使用缓存好的线程，而不是新线程
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
    }

}

执行结果图: 在这里插入图片描述
定长线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    /**
     * 定长线程池.
     * (长度是指定的数值) * 执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     */
    public static void main(String[] args) throws InterruptedException {

        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        Thread.sleep(1000);
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
    }

}

执行结果图:
在这里插入图片描述
定长线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    /**
     * 单线程线程池. 执行流程:
     * 1. 判断线程池 的那个线程 是否空闲
     * 2. 空闲则使用
     * 4. 不空闲,则等待 池中的单个线程空闲后 使用
     */
    public static void main(String[] args) throws InterruptedException {

        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
        Thread.sleep(1000);
        service.execute(() -> {
            System.out.println(Thread.currentThread().getName() + ", 线程执行中");
        });
    }

}

执行结果图:
在这里插入图片描述
周期任务定长线程池

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {

    /**
     * 周期任务 定长线程池.
     * 执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 *
     * 周期性任务执行时:
     * 定时执行, 当某个时机触发时, 自动执行某任务 .
     */
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 1. 定是执行一次
         * 参数1： 定时执行的任务
         * 参数2： 时长数字
         * 参数3： 时长数字的时间单位，TimeUnit的常量指定
         */
        service.schedule(() -> {
            System.out.println(Thread.currentThread().getName() + ", 5秒后执行的任务");
        } ,5, TimeUnit.SECONDS);

        /**
         * 周期性执行任务
         * 参数1： 任务
         * 参数2： 延迟时长数字
         * 参数3： 周期时长数字
         * 参数4： 时长数字单位
         */
        service.scheduleAtFixedRate(() -> {
            System.out.println(Thread.currentThread().getName() + ", 五秒后执行，每隔一秒执行一次");
        }, 5, 1, TimeUnit.SECONDS);
    }

}

执行结果图：
在这里插入图片描述
线程池可以调用shutdown()关闭线程池。

setSail0607
关注
Java 多线程总结笔记
N0tExpecterr0r的博客
09-19 4434
Java多线程总结笔记 实现多线程的方法 查看Thread类的源码，可以发现它实现了Runnable接口，然后在自己的run方法中调用了Runnable的run方法。这里其实就是静态代理这一设计模式，Thread是代理角色，而Runnable则是真实角色。在Thread的start方法中，会为我们开辟新的线程并执行其run方法，而Thread的run方法会调用它内部持有引用的Runnable的ru...
Delphi多线程总结
疯流人物
10-23 2739
多线程总体认识 当前程序是一个进程, 进程只是一个工作环境, 线程是工作者; 每个进程都会有一个启动线程(或叫主线程), 也就是说: 大量的编码都是写给这个主线程的; ExitThread(0); 退出主线程; 系统不允许一个没有线程的进程存在, 所以程序就退出了. ExitThread 函数的参数是一个退出码, 这个退出码是给之后的其他函数用的, 这里随便给个无符号整数即可. ...
Java多线程总结（超详细总结）
唯有努力，方可自信！
05-09 7153
Java多线程总结1.创建线程的方式方式1方式2方式3方式42.线程安全引出线程安全（卖票例子）解决方式方式一方式二 1.创建线程的方式 方式1 继承于Thread类 创建一个继承于Thread类的子类 重写Thread类的run() --> 将此线程执行的操作声明在run()中 创建Thread类的子类的对象 4. 通过此对象调用start() 例子：遍历100以内的所有的偶数 class MyThread extends Thread { //2. 重写Thread类的run()
Java多线程总结
琦彦
02-07 1万+
前言Java语言一个重要的特点就是内置了对并发的支持，让Java大受企业和程序员的欢迎。在典型的Java面试中， 面试官会从线程的基本概念问起,  如：为什么你需要使用线程， 如何创建线程，用什么方式创建线程比较好（比如：继承thread类还是调用Runnable接口），然后逐渐问到并发问题像在Java并发编程的过程中遇到了什么挑战，Java内存模型，JDK1.5引入了哪些更高阶的并发工具，并发编...
超详细，Python 多线程总结的太到位了
Python学习与数据挖掘
10-30 4027
B站同名【有温度的算法】已经上线想观看视频讲解的同学在文末点击【原文链接】直达B站多线程常用模板在实际处理数据时，因系统内存有限，我们不可能一次把所有数据都导出进行操作，所以需要批量导出依次操作。为了加快运行，我们会采用多线程的方法进行数据处理，以下为我总结的多线程批量处理数据的模板：import threading # 从数据库提取数据的类 class Scheduler():     def __init__(self):
JAVA多线程总结
zyjdreamm的博客
11-15 1843
1、什么是多任务 多任务就是在同一时间做多件事情，如边吃饭边玩手机等。看起来是多个任务都在做，本质上我们的大脑在同一时间依旧只做了一件件事情 2、什么是程序 程序是指令和数据的有序集合，其本身没有任何运行含义，是一个静态概念 3、什么叫进程 进程是执行程序的一次过程，它是一个动态概念，是系统资源分配的单位 小结：通常在一个进程是包含若干个线程，进程中至少有一个线程，不然没有存在的意义，线程是cpu调度和执行的单位 注：很多线程是我们模拟出来的，真是的线...
python多线程总结
星空下的密码
08-09 6588
多线程总结 话说多线程认识让我恼火了一阵子，很是不习惯程序跳来跳去的执行，毫无时间和空间逻辑的感觉了，现在对我所见的总结一下吧，其实多线程呢在目前的语言中都是差不多，所以只要你理解了多线程在任何语言都是使用的，不同的就是语法不同而已吧  1. 多线程内幕： 什么是多线程，说白了就是多个线程并发的执行， 既然是并发执行，但是cpu是不可能同时执行多个线程吧，所以怎么办呢，其实是一个假象
多线程基本总结思维导图
qq_43251445的博客
03-25 1576
多线程基本总结思维导图
java多线程总结
勿在浮沙筑高台
02-17 1万+
Java多线程总结 线程的概念 在开始学习编程时，我们写的程序都是顺序执行。 例如这个场景：我们正在烧水等水开，此时有人敲门，我们需要等水烧开再去开门，这是单线程顺序执行（容易造成阻塞）。那么多线程呢？在等水烧开的时候，有人敲门那么我们就是开门，之后继续去烧水。也就是事情没有被阻塞住。 我们在写顺序程序的时候其实是有一个线程的，并且只有一个线程。多个线程是为了合理利用cup,加快事情的...
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
C#.net同步异步SOCKET通讯和多线程总结2[参照].pdf
10-11
C#.net 同步异步 SOCKET 通讯和多线程总结 本文旨在总结 C#.net 中的同步异步 SOCKET 通讯和多线程编程，涵盖服务端和客户端的实现细节。 一、服务端实现 服务端使用 System.Net 和 System.Net.Sockets 命名空间...
C++多线程总结[归纳].pdf
10-19
C++多线程总结 本文档对C++多线程编程进行了总结，介绍了三种创建线程的方法：CreateThread函数、AfxBeginThread函数和_beginthread()/_beginthreadex()函数，同时对线程的管理和终止进行了详细的讲解。 ...
C#.net同步异步SOCKET通讯和多线程总结
10-06
C#.net同步异步SOCKET通讯和多线程总结 C#.net同步异步SOCKET通讯和多线程总结是指在C#.net环境下实现的同步异步套接字通信和多线程编程的总结。套接字（Socket）是tcp/ip网络协议接口，内部定义了许多的函数和例程...
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
Java-网络
2301_81543552的博客
09-14 784
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
最新发布
m0_74972727的博客
09-15 791
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 803
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
自动生成不重复的订单id
ClaireCheney的博客
09-13 346
【代码】自动生成不重复的订单id。
iOS多线程总结：深度解析GCD的使用
"iOS 多线程总结之GCD的使用详解" 在iOS开发中，多线程技术是不可或缺的一部分，特别是在处理耗时操作时，如网络请求、数据解析等，多线程能确保用户界面的流畅性。Grand Central Dispatch (GCD) 是苹果提供的一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值