并发基础——多线程

最新推荐文章于 2024-02-19 11:37:25 发布
最新推荐文章于 2024-02-19 11:37:25 发布
阅读量112 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40754146/article/details/107196204
版权

一，宏观概念

1，进程和线程

  • 进程是独立应用程序，线程是进程的一条执行路径。
  • 一个进程通常有N个线程

2，多线程

指进程中的多个路径同时执行，主要目的是提高程序效率。


【举个栗子】：

打开网易云音乐，可以理解为一个进程，然后点开一首歌曲，这是一个线程，然后在播放歌曲的同时，可以在下边评论，这就是两个线程。


3，并发与并行

多线程是针对单核CPU的，也就是并发。

多核CPU的多个核心同时运算称为并行。


4，多线程的使用场景

多线程的本质是CPU时间片的快速切换，当并发操作次数很大时，可以忽略掉创建线程和线程切换的开销，但是如果并发量很小，多线程就显得多此一举了。


二，多线程创建方式


1.继承Thread，重写run方法

在晴朗早晨，和朋友一边散步一边聊天.....

CPU交替执行三件事，但切换速度很快，感觉上就是在同时进行......

class ThreadWalk extends  Thread
{
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println("Walk。。。。。");
        }

    }
}

class ThreadTalk extends Thread
{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Talking........");
        }

    }
}



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

        for (int i = 0; i < 10; i++) {
            System.out.println("Sunshine.....");
        }

        ThreadWalk threadWalk = new ThreadWalk();
        threadWalk.start();

        ThreadTalk threadTalk = new ThreadTalk();
        threadTalk.start();

        

    }
}

运行结果：

Sunshine.....
Sunshine.....
Sunshine.....
Sunshine.....
Sunshine.....
Sunshine.....
Sunshine.....
Sunshine.....
Sunshine.....
Sunshine.....
Walk。。。。。
Walk。。。。。
Walk。。。。。
Walk。。。。。
Walk。。。。。
Walk。。。。。
Walk。。。。。
Walk。。。。。
Walk。。。。。
Walk。。。。。
Talking........
Talking........
Talking........
Talking........
Talking........
Talking........
Talking........
Talking........
Talking........
Talking........

Process finished with exit code 0

2. 实现Runnable接口

可继承多个接口，弥补单继承的不足

class MyRunnable1 implements Runnable
{
    int i=10;
    public void run()
    {
        for(;i>0;)
        {
            System.out.printf("day"+"\n");
            i--;
        }
    }
}
class MyRunnable2 implements Runnable
{
    int j=10;
    public void run()
    {
        for(;j>0;)
        {
            System.out.printf("night"+"\n");
            j--;
        }
    }
}
public class Main
{
    public static void main(String []args)
    {
        MyRunnable1 runnable1 = new MyRunnable1();
        MyRunnable2 runnable2 = new MyRunnable2();

        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        thread1.start();
        thread2.start();
        for(int k=0;k<10;k++)
        {
            System.out.printf("main thread..."+"\n");
        }
    }
}

运行结果：

main thread...
main thread...
main thread...
main thread...
main thread...
night
night
night
night
night
night
night
night
night
night
day
day
day
day
day
day
day
day
day
day
main thread...
main thread...
main thread...
main thread...
main thread...

3.匿名内部类实现多线程

public class Main
{
    public static void main(String []args)
    {
        Thread thread = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i <10 ; i++) {
                            System.out.println("no Name thread。。。。");
                        }
                    }
                }
        );
        thread.start();

        for(int k=0;k<10;k++)
        {
            System.out.printf("main thread..."+"\n");
        }
    }
}

运行结果：

main thread...
main thread...
main thread...
main thread...
main thread...
main thread...
main thread...
no Name thread。。。。
no Name thread。。。。
no Name thread。。。。
no Name thread。。。。
main thread...
main thread...
main thread...
no Name thread。。。。
no Name thread。。。。
no Name thread。。。。
no Name thread。。。。
no Name thread。。。。
no Name thread。。。。

4，实现Callable接口

public class CreatThreadDemo4 implements Callable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CreatThreadDemo4 demo4 = new CreatThreadDemo4();

        FutureTask<Integer> task = new FutureTask<Integer>(demo4); //FutureTask最终实现的是runnable接口

        Thread thread = new Thread(task);

        thread.start();

        System.out.println("我可以在这里做点别的业务逻辑...因为FutureTask是提前完成任务");
        //拿出线程执行的返回值
        Integer result = task.get();
        System.out.println("线程中运算的结果为:"+result);
    }

    //重写Callable接口的call方法
    @Override
    public Object call() throws Exception {
        int result = 1;
        System.out.println("业务逻辑计算中...");
        Thread.sleep(3000);
        return result;
    }
}

5，使用线程池

public class CreatThreadDemo6 {
    public static void main(String[] args) {
        //创建一个具有10个线程的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        long threadpoolUseTime = System.currentTimeMillis();
        for (int i = 0;i<10;i++){
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"线程执行了...");
                }
            });
        }
        long threadpoolUseTime1 = System.currentTimeMillis();
        System.out.println("多线程用时"+(threadpoolUseTime1-threadpoolUseTime));
        //销毁线程池
        threadPool.shutdown();
        threadpoolUseTime = System.currentTimeMillis();
    }

}

6，使用定时器Timer

public class CreatThreadDemo5 {

    public static void main(String[] args) {
        Timer timer = new Timer();

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("定时器线程执行了...");
            }
        },0,1000);   //延迟0，周期1s

    }
}

7，使用Java8新特性stream

public class CreatThreadDemo7 {
    public static void main(String[] args) {
        List<Integer> values = Arrays.asList(10,20,30,40);
        //parallel 平行的，并行的
        int result = values.parallelStream().mapToInt(p -> p*2).sum();
        System.out.println(result);
        //怎么证明它是并发处理呢
        values.parallelStream().forEach(p-> System.out.println(p));
    }
}

三，守护线程

主线程：main方法所在线程

用户线程（子线程）：main方法中创建的子线程

守护线程：和main方法一起销毁的线程，比如说GC线程

非守护线程：main方法销毁依然执行的线程


thread.setDaemon(true);可设置线程为守护线程

class  Main
{
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i <10 ; i++) {
                    System.out.println("子线程...");
                }
            }
        });
//        thread.setDaemon(true);
        thread.start();

        for (int i = 0; i <10 ; i++) {
            System.out.println("main线程.....");
        }

        System.out.println("主线程销毁....");



    }
}

四，join方法

在线程中调用另一个线程的join方法会暂时停止当前线程，将CPU资源给另一个线程先使用。

class  Main
{
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    System.out.println("子线程...");
                }
            }
        });

        thread.start();

        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i <10 ; i++) {
            System.out.println("main线程.....");
        }

        System.out.println("主线程销毁....");



    }
}
子线程...
子线程...
子线程...
子线程...
子线程...
子线程...
子线程...
子线程...
子线程...
子线程...
main线程.....
main线程.....
main线程.....
main线程.....
main线程.....
main线程.....
main线程.....
main线程.....
main线程.....
main线程.....
主线程销毁....

六，线程安全问题

当多个线程同时共享，同一个全局变量或静态变量，进行写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是进行读操作是不会发生数据冲突问题。


本质上是数据一致性问题。


Synchronized

  • 关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块
  • synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性)

非静态同步方法

经典火车售票问题

class  ThreadDemo implements Runnable
{
    private static int count = 100;

    //非静态同步方法
    public synchronized void sale()
    {
        if(count>0)
        {
            count--;
            System.out.println(Thread.currentThread().getName()+"剩余票数"+count);
        }

    }

    @Override
    public void run() {
        while(count>0)
        {
            sale();
        }
    }
}


public class Main{

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();

        Thread t1 = new Thread(threadDemo,"Window1");
        Thread t2 = new Thread(threadDemo,"WIndow2");

        t1.start();
        t2.start();


    }
}

静态同步方法

class  ThreadDemo implements Runnable
{
    private static int count = 100;

    //静态同步方法
    public synchronized static void sale()
    {
        if(count>0)
        {
            count--;
            System.out.println(Thread.currentThread().getName()+"剩余票数"+count);
        }

    }

    @Override
    public void run() {
        while(count>0)
        {
            sale();
        }
    }
}


public class Main{

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();

        Thread t1 = new Thread(threadDemo,"Window1");
        Thread t2 = new Thread(threadDemo,"WIndow2");

        t1.start();
        t2.start();


    }
}

同步代码块

class  ThreadDemo implements Runnable
{
    private static int count = 100;

    //同步代码块
    public  void sale()
    {
        synchronized(this)
        {
            if(count>0)
            {
                count--;
                System.out.println(Thread.currentThread().getName()+"剩余票数"+count);
            }
        }


    }

    @Override
    public void run() {
        while(count>0)
        {
            sale();
        }
    }
}


public class Main{

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();

        Thread t1 = new Thread(threadDemo,"Window1");
        Thread t2 = new Thread(threadDemo,"WIndow2");

        t1.start();
        t2.start();


    }
}

非静态同步方法和静态同步方法的区别

前者同步在对象层面上，后者同步在类的层面上

非静态同步方法和同步代码块的区别

前者在方法上，后者在方法内部。范围不同。

通常来说，范围越大，性能越差。

死锁

同步中嵌套同步,导致锁无法释放。


有两个线程并行执行，当线程1拿到了obj1锁，线程2拿到了obj2锁，就会出现互相等待的情况。

线程1拿着obj1等待obj2，线程2拿着obj2等着obj1.

class ThreadDemo implements Runnable {
    private static int count = 100;

    private Object obj1 = new Object();
    private Object obj2 = new Object();

    public void sale() {
        synchronized (obj1) {
            synchronized (obj2) {
                if (count > 0) {
                    count--;
                    System.out.println(Thread.currentThread().getName() + "剩余票数" + count);
                }
            }

        }
    }

    @Override
    public void run() {

        synchronized (obj2) {
            synchronized (obj2) {
                sale();

            }

        }
    }
}


public  class Main{

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();

        Thread t1 = new Thread(threadDemo,"Window1");
        Thread t2 = new Thread(threadDemo,"WIndow2");

        t1.start();
        t2.start();


    }
}

多线程三大特性

  • 原子性

    一个操作或者多个操作要么全部执行，要么都不执行；在多线程中，原子性主要体现在数据一致性上。

  • 可见性

    当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

  • 有序性

    程序执行的顺序按照代码的先后顺序执行。

七，Java内存模型

Java内存模型(JMM)主要目标是定义程序中共享变量（线程共享）的访问规则。


JMM规定线程之间的共享变量存储在主内存中，每个线程都有一个本地内存（工作内存），本地内存存储了共享变量的副本。


Volatile关键字

volatile是一种轻量级的同步机制，可以保证可见性【及时将修改的变量刷新到主内存中】，但不能保证原子性，并且禁止重排序。

应用场景：全局共享变量

Volatile的可见性：一旦某个线程修改了该被volatile修饰的变量，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，可以立即获取修改之后的值。

Synchronized和Volatile的区别

JMM关于synchronized的两条规定：

  • 线程加锁时，将清空工作内存中共享变量的值（本地内存已经有备份了）
  • 线程解锁前，必须把本地内存的最新值刷新到主内存

　　　（注意：加锁与解锁需要是同一把锁）

通过以上两点，可以看到synchronized能够实现可见性。同时，由于synchronized具有同步锁，所以它也具有原子性

Synchronized同时具有原子性和可见性，但效率低

Volatile仅具有可见性，但效率高

重排序

重排序是指CPU对代码的优化，但是不会对有依赖关系代码做重排序。

比如说

int x = 3;       -----1
int y = 5;       -----2
int z = x+y;     -----3

1和2的执行顺序可能会发生改变，但一定在3之前。

【举个栗子】

定义两个静态变量，创建一个读线程，一个写线程。

如果是按照顺序执行的话，读线程会读到从1到5连续或者相同的数字。

public class Main {
    private static int a=0;
    private static int b=0;


    public static void main(String[] args) {

        Thread t1_write = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                while (true)
                {

                    a = 1;   // 这里可能发生重排序
                    b = 1;   // 这里可能发生重排序

                    a = 2;   // 这里可能发生重排序
                    b = 2;   // 这里可能发生重排序

                    a = 3;   // 这里可能发生重排序
                    b = 3;   // 这里可能发生重排序

                    a = 4;   // 这里可能发生重排序
                    b = 4;   // 这里可能发生重排序

                    a = 5;   // 这里可能发生重排序
                    b = 5;   // 这里可能发生重排序

                    a = 4;   // 这里可能发生重排序
                    b = 4;   // 这里可能发生重排序

                    a = 3;   // 这里可能发生重排序
                    b = 3;   // 这里可能发生重排序

                    a = 2;   // 这里可能发生重排序
                    b = 2;   // 这里可能发生重排序

                }


            }
        });

        Thread t2_read = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                while(true)
                {
                    System.out.println("a="+a);
                    System.out.println("b="+b);
                    System.out.println("=========================");
                }

            }
        });



        t1_write.start();
        t2_read.start();


    }
}

运行结果有的连续，有的并不连续，说明在执行读线程的时候，CPU进行了重排序。但是重排序只是一种情况。也有可能a=2时，执行读线程，输出b的时候a仍在执行，这种情况也会导致不连续。

如何用代码验证重排序目前还没有想出可行的方法，欢迎小伙伴们提出解决方法。^_^

Noneplus
关注
java并发模拟——多线程计数
ning1994724的博客
12-13 1699
java并发模拟——多线程计数 最近在学习多线程与高并发的知识，这是一个能力进阶的必要途径。在大量的系统中，都会多多少少存在并发问题，如何更好的解决高并发是一个探究的问题。 下面我准备了一个简单的多线程计数demo来模拟并发操作，观察打印输出情况，真正的去感受一下并发操作。 首先环境搭建，我用的是springboot，在spring官网或者idea中初始化一个maven项目 生成项目之后，先配置p...
python线程安全字典_python并发编程——多线程
weixin_42220669的博客
12-24 1315
python并发编程——多线程编程的乐趣在于让程序越来越快，这里将给大家介绍一个种加快程序运行的的编程方式——多线程1 著名的全局解释锁(GIL)说起python并发编程，就不得不说著名的全局解释锁(GIL)了。有兴趣的同学可以我查找一下相关的资料了解一下GIL,在这里大家只要知道一点，因为GIL的存在，对于任何Python程序，不管有多少的处理器，任何时候都总是只有一个线程在执行。下面先看一个例...
Java学习笔记--线程和多线程线程池（简单理解）
qq_38409944的博客
05-02 575
线程： 单核的cpu在一个时间片中只能执行一个应用程序 各个程序其实在做cpu的资源真多战而已 cpu做了快速的切换动作 疑问 ：线程负责了代码 的执行，我们之前没有学过线程，为什么代码可以执行呢？ 运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码。 一个java应用程序至少有几个线程？ 至少有两个线程， 一个是主线程负责m...
线程创建，线程的方法
weixin_45192252的博客
07-19 363
进程： 正在运行的一个程序叫做进程：进程负责了内存空间的划分 问题： windows号称是多任务的操作系统，那么windows是同时运行多个应用程序吗？ 从宏观的角度： windows确实在同时运行多个应用程序 从微观的角度： cpu是做了一个快速切换执行的动作，由于速度太快，所有我们感觉不到切换而已。 线程： 线程在一个进程中负责了代码的执行，就是进程中一个执行路 径 多线程： 在一个进程...
python并发爬虫——多线程、线程池实现
sixteen_16的博客
04-27 6898
python并发爬虫——多线程、线程池实现 一个网络爬虫通常由发送请求、获取响应、解析页面、本地保存等这几部分组成。其中最难，细节最多的当然是页面解析环节，对于不同的页面，其解析难度必然又所差异，甚至有些安全性较高的网站还设有各种反扒机制，想要获取需要的信息需要视具体情况而言。当然这些内容不在本篇的介绍范围内。本文主要内容是针对如何使用多线程、线程池进行并发操作，提高爬虫的爬取效率。 一、常规网络爬虫 1. 执行顺序 通常，我们在使用爬虫对网页进行爬取的时候，往往采用requests库发送get请求，获取响
高并发之——多线程并发与线程安全总结
冰河的专栏
10-26 1254
可以参考如下博文： 《Java之——内存模型》 《高并发之——如何安全的发布对象（含各种单例代码分析）》 《高并发之——线程安全性》 《高并发之——线程安全策略》 《高并发之——AQS》 《高并发之——J.U.C组件扩展》 《高并发之——线程池》 《高并发之——死锁，死锁的四个必要条件以及处理策略》 《高并发之——多线程并发扩展》 ...
【JVM并发编程专题】——多线程基础
weixin_44275259的博客
06-03 8966
基础——线程内核 进程基本定义： 进程是资源分配的最小单位，比如说向操作系统征用4G的内存区域，所以不同进程虚拟内存空间的地址是独立，如果进程要通信就必须通过特殊的方式通信，比如：FIFO、管道消息、共享内存、队列、信号量，当然这个不作为本章的重点内容； 线程基本定义： 线程是CPU调度的最小单位，比如说你的一个JVM虚拟机中不同的需要对不同ip的用户请求来建立线程来处理，供cpu调度，而这些过程中产生的数据都存在进程为你征用的内存区域；线程的本质就是一段要执行的代码而已； 内核线程多路复用机制：
C语言系列12——多线程与并发编程
theskylife的博客
02-19 3462
在计算机编程领域，多线程与并发编程是一项重要的技术，它允许程序同时执行多个任务，提高了系统资源的利用率和程序执行效率。本文将介绍多线程的基本概念、应用场景，以及如何使用POSIX线程库进行编程，同时探讨线程同步与互斥锁的原理与应用，以避免竞态条件的发生。
Java——多线程高并发系列之volatile关键字
★★光亭★★
06-07 6956
Java——多线程高并发系列之volatile关键字
Java——多线程高并发系列之ThreadLocal的使用
★★光亭★★
06-08 6791
Java——多线程高并发系列之ThreadLocal的使用
iOS高级程序员进阶——多线程编程核心技术模式篇
06-18
多线程是一种软件实现多个线程并发执行任务的技术。在iOS开发中，实现多线程的的方式有很多种，常用的有pthread、NSThread、GCD与NSOperation。在实际应用中，多线程技术也有着非常多的使用场景，比如异步的网络请求...
并发编程——线程基础.pdf
06-06
在当前的计算机科学和软件开发领域，多线程编程是一项非常核心和重要的技能。随着计算机硬件技术的发展，多核处理器的普及，多线程成为了提高程序性能和充分利用多核处理器资源的重要手段。尤其在Java这种广泛使用的...
Java练手小项目——多线程聊天室.zip
01-14
【Java练手小项目——多线程...通过这个“Java练手小项目——多线程聊天室”，你可以深入了解Java多线程的原理和实践，同时学习到网络编程和并发集合的运用，这对于提升你的Java编程技能和解决实际问题的能力大有裨益。
VB程序实例-运用Mschat图表显示数据(方法二).zip
11-03
VB程序实例-运用Mschat图表显示数据(方法二).zip
VB程序实例-改变Windows图标大小.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
技术资料分享ZigBee协议栈的研究与实现非常好的技术资料.zip
11-03
技术资料分享ZigBee协议栈的研究与实现非常好的技术资料.zip
pytz-2016.10-py3.1.egg
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
技术资料分享ADV7123非常好的技术资料.zip
11-03
技术资料分享ADV7123非常好的技术资料.zip
技术资料分享MP1541非常好的技术资料.zip
11-03
技术资料分享MP1541非常好的技术资料.zip
Java多线程并发特性解析——掌握线程、锁与原子操作
掌握这些并发编程的基础知识和高级特性，对于编写健壮的多线程Java应用程序至关重要。" 说明.txt文件可能包含了如下的更详细信息： "本文档将详细介绍Java中实现并发的多种模式和特性。首先，会介绍线程的基本概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值