多线程总结

最新推荐文章于 2022-07-30 17:14:19 发布
最新推荐文章于 2022-07-30 17:14:19 发布
阅读量142 收藏 1
点赞数
分类专栏： Java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41704268/article/details/108955847
版权

多线程

线程与进程

进程：

  • 是指一个内存中的应用程序，每个进程都有一个独立的内存空间。

线程：

  • 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程至少有一个线程。
  • 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分为若干的线程

线程的调度

分时调度

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

抢占式调度

  • 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），java使用的是抢占式调度。
  • CPU使用抢占式调度模式在多个线程中进行着告诉切换。对于一个CPU而言，某个时候，只能执行一个线程，而CPU在多个线程间切换速度相对我们的感觉要快，看上去就像在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但是能够提高程序运行效率，让CPU的使用率更高。

同步与异步

同步：排队执行，效率低但安全。
异步：同步执行，效率高但数据不安全。
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一个时刻发生（同时发生）

继承Thread

实现多线程的一种方式
实例：

public class Demo4 {
    public static void main(String[] args) {
        //Thread
        MyThread m = new MyThread();
        m.start();
        for (int i=0;i<10;i++){
            System.out.println("汗滴禾下土"+i);
        }
    }
}
class MyThread extends Thread{
    /**
     * run方法就是线程要执行的人物方法
     */
    @Override
    public void run() {
        //这里的代码就是一条新的执行路径。
        //这个执行路径的触发方式，不是调用run方法，而是通过Thread对象的start()来启动任务
        for (int i=0;i<10;i++){
            System.out.println("锄禾日当午"+i);
        }
    }
}

两条线程所执行的时序图：
程序启动
main线程开启
main线程执行
创建m对象
循环10次
程序结束
m线程开启
循环10次

实现Runnable

第二种实现多线程的方法
实例：

public class Demo5 {
    public static void main(String[] args) {
        MyRunnable m = new MyRunnable();
        Thread t = new Thread(m);
        t.start();
        for (int i=0;i<5;i++){
            System.out.println("汗滴禾下土"+i);
        }
    }
}
class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i=0;i<5;i++){
            System.out.println("锄禾日当午"+i);
        }
    }
}

实现Runnable接口与继承Thread相比有如下优势：

  1. 通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程执行相同的任务。
  2. 可以避免单继承所带来的局限性。
  3. 任务与线程本身是分离的，提高了程序的健壮性。
  4. 后续学习的线程池技术，接收Runnable类型的任务，不接受Thread类型的任务。

Thread也有优势比如可以很简单的实现方式，通过匿名内部类的方法开启一个线程。
例：

public class Demo5 {
    public static void main(String[] args) {
    //匿名内部类方法开启新的线程
        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<5;i++){
                    System.out.println("锄禾日当午"+i);
                }
            }
        }.start();
        for (int i=0;i<5;i++){
            System.out.println("汗滴禾下土"+i);
        }
    }
}

Thread类

常用构造方法：

构造器描述
Thread()分配新的 Thread对象。
Thread​(Runnable target)分配新的 Thread对象。
Thread​(Runnable target, String name)分配新的 Thread对象。
Thread​(String name)分配新的 Thread对象。

常用的方法：

变量和类型方法描述
longgetId()返回此Thread的标识符。
StringgetName()返回此线程的名称。
intgetPriority()返回此线程的优先级。
voidsetPriority​(int newPriority)更改此线程的优先级。
static ThreadcurrentThread()返回对当前正在执行的线程对象的引用。
voidstart()导致此线程开始执行; Java虚拟机调用此线程的run方法。
static voidsleep​(long millis)导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。
static voidsleep​(long millis, int nanos)导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统定时器和调度程序的精度和准确性。
voidsetDaemon​(boolean on)将此线程标记为 daemon线程或用户线程。

daemon(守护线程)是依附于用户线程的。

面试题：
如何将一个线程停止：
不能使用stop()方法，因为stop()方法极有可能导致操作在没有执行完的时候就被终止导致资源没有被释放，从而占用资源。
正确的方法是使用标记的方法，在线程执行过程中不断观察，一旦标记改变，return返回run方法就可以了。

线程阻塞（耗时操作）

简单的可以理解为所有需要消耗时间的操作。例：文件读取，接受用户输入

线程中断

概述：
一个线程是一个独立的执行路径，他是否应该结束，应该由其自身决定。

使用interrupt()方法进行中断操作。

守护线程

用于守护用户线程。
用户线程：当一个进程不包含任何存活的用户线程时，进程结束。
守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动结束。
如何设置：

//只需要在线程开始前将其设置为守护线程即可。
Thread t1 = new Thread(new MyRunnable());
//这样就将t1设置为了守护线程。
t1.setDaemon(true);

线程安全问题

线程不安全 案例：

public static void main(String[] args){
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        private int count = 10;

        @Override
        public void run() {
            while(count>0){
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功，剩余票数为："+count);
            }
        }
    }

卖票（因为多个线程去争抢同一个数据count），所以有可能出现count=-1或者-2的情况，因为一旦在还没减到0的时候其他的线程也可能会抢到时间片导致线程并没有结束，所以并不安全。

线程安全

线程同步synchronized

**线程不安全解决方案1：**同代码块

**格式：**synchronized(锁对象){}

注：每一个线程要看同一把锁，这样才有会实现线程安全，如果每个人都看自己的锁，那是没有意义的。

例：

public static void main(String[] args){
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        private int count = 10;
        //对象要new在run()的外部，这样可以保证三个线程看的是同把锁，如果new在run()中，那每个线程在调用run()的时候都会自己生成一把锁，这样同步代码块就失去了意义。
        private Object o = new Object();
        @Override
        public void run() {
            while(true){
            //在while循环里保证将卖票这个操作上锁
                synchronized (o){
                    if (count>0){
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"出票成功，剩余票数为："+count);
                    }
                }
            }
        }
    }

**线程不安全解决方案2：**同代方法
用方法来实现
例：

public static void main(String[] args){
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        private int count = 10;

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

        public synchronized boolean sale(){
            if (count>0){
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"出票成功，剩余票数为："+count);
                return true;
            }
            return false;
        }
    }

**注：**如果一个类中有很多个同步方法，那么他们用的锁都是同一个this，当其中一个方法执行，其他的方法也需要等待。

**线程不安全解决方案3：**显示锁Lock
例：

public static void main(String[] args){
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        //显示锁
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while(true){
                l.lock();
                if (count>0){
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，剩余票数为："+count);
                }else {
                    break;
                }
                l.unlock();
            }
        }
    }

公平锁

java中默认的都是不公平的锁（同步代码块、同步方法、显示锁）。
Lock实现公平锁，显示锁的构造方法可以传入一个布尔类型的值默认为false，设置为true则将Lock更改为公平锁。

线程死锁

案例：

public static void main(String[] args) {
        Culprit c = new Culprit();
        Police p = new Police();

        new MyThread(c,p).start();
        c.say(p);
    }
    static class MyThread extends Thread{
        private Culprit c;
        private Police p;

        public MyThread(Culprit c, Police p) {
            this.c = c;
            this.p = p;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }

    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
            p.fun();
        }

        public synchronized void fun(){
            System.out.println("罪犯被放了，警察也救到了人质");
        }
    }

    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放过你");
            c.fun();
        }

        public synchronized void fun(){
            System.out.println("警察就到了人质，罪犯被放走了");
        }

    }

多线程通讯问题

线程的六种状态

NEW：尚未启动的线程处于此状态。
RUNNABLE：在Java虚拟机中执行的线程处于此状态。
BLOCKED：被阻塞等待监视器锁定的线程处于此状态。
WAITING：无限期等待另一个线程执行特定操作的线程处于此状态。
TIMED_WAITING：正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
TERMINATED：已退出的线程处于此状态

带返回值的线程Callable

接口定义 
//Callable接口
public interface Callable<V> {
    V call() throws Exception;
} 
//Runnable接口
public interface Runnable {
    public abstract void run();
}

使用步骤：

 1. 编写类实现Callable接口 , 实现call方法 
			class XXX implements Callable<T> {
			            @Override
			            public <T> call() throws Exception {
								return T; 
						}
			}
 2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
			FutureTask<Integer> future = new FutureTask<>(callable); 
 3. 通过Thread,启动线程
			new Thread(future).start();

Runnable 与Callable

相同点：都是接口、都可以编写多线程程序、都采用Thread.start()启动线程。
不同点：
1.Runnable没有返回值，Callable可以返回执行结果。
2.Callable的cal()允许抛出异常，Runnable的run()不能抛出异常。
获取返回值：Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执 行，如果不调用不会阻塞。

线程池

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

线程池的优点：

  • 降低资源消耗
  • 提高响应速度
  • 提高线程的可管理性

缓存线程池

例：

public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称："+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称："+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称："+Thread.currentThread().getName());
            }
        });
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称："+Thread.currentThread().getName());
            }
        });
    }

定长线程池

public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程名称："+Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程名称："+Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程名称："+Thread.currentThread().getName());
            }
        });
    }

但线程线程池

public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称："+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称："+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称："+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称："+Thread.currentThread().getName());
            }
        });
    }

周期定长线程池

public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
service.schedule(new Runnable() {
@Override
public void run() {
System.out.println(“线程名称：”+Thread.currentThread().getName());
}
},5,TimeUnit.SECONDS);
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println(“线程名称：”+Thread.currentThread().getName());
}
},3,1, TimeUnit.SECONDS);
}

Lambda表达式

函数式编程思想。
注：想要实现Lambda表达式的接口必须只有一个静态方法。因为Lambda表达式是为了实现这个方法所以才可以替换为一个函数表达式
例：

public static void main(String[] args) {
        print((int x, int y) -> {
                return x+y;
            },100,200);
    }

    public static void print(MyMath m,int x,int y){
        int num = m.sum(x,y);
        System.out.println(num);
    }
    static interface MyMath{
        int sum(int x,int y);
    }
蕉虑少年
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程知识点总结
m0_50691158的博客
09-21 374
多线程知识点总结
Java多线程总结
01-20
然后通过此Thread类调用方法run()来完成其运行操作的，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程终止，而CPU再运行其它线程。 　而如果直接用Run方法，这只是调用一个...
java虚拟机中多线程总结
08-25
Java虚拟机中多线程总结 Java虚拟机中多线程总结是指在Java虚拟机中，对多线程的知识点总结内容。本篇内容将从多线程的基本概念开始，讲解多线程的优点、缺点、分类、创建方式、同步机制等知识点，并且从JVM的角度...
Java-学习多线程总结上
12-22
多线程 1. 多线程的基本概念 每一个正在执行的程序都是一个进程，资源只有一块，所以在同一时间段会有多个程序同时执行，但是在一个时间点上，只能由一个程序执行，多线程是在一个进程的基础之上的进一步划分，因为...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程的总结
12-02
Java多线程的重要性可想而知，而对于多线程，某些情况下，又比较难理解，稍微参照网上的资料进行了总结
Java 多线程学习总结归纳（附代码）
01-09
这是本人在学习Java 多线程时的总结归纳以及代码，希望对下载的同学有帮助！
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
多线程有这一篇就够（超详细万字总结）
m0_64201189的博客
07-30 523
想要了解多线程，或者是应对面试等需要掌握多线程的基础知识。 建议浏览本文章 跟着代码敲一遍 就可以基本了解多线程
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 1984
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
Java多线程
南_茗的博客
05-21 474
为了更好的利用cpu的资源，如果只有一个线程，则第二个任务必须等到第一个任务结束后才能进行，如果使用多线程则在主线程执行任务的同时可以执行其他任务，而不需要等待。
Java多线程总结：线程状态与管理
本文为理解Java多线程的基本概念和操作提供了很好的基础，对于理解和编写多线程程序具有指导意义。在实际开发中，我们还需要掌握更高级的同步机制，如`synchronized`关键字、`Lock`接口及其实现、条件变量等，以及...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值