多线程与高并发之（一）线程的基本概念

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量149 收藏 2
点赞数 1
分类专栏： 多线程与高并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42324034/article/details/110456523
版权

线程的基本概念

基本概念

什么叫进程？什么叫进程？
进程： 假设你的硬盘上有一个“英雄联盟”的程序，这就是一个程序，是一种静态的概念，当你打开它，弹出一个界面输入账号密码，这个时候就叫做一个进程，进程相对程序来说是一种动态的概念。
线程： 作为一个进程里面最小的执行单元就叫做一个线程，简单的说就是一个程序里不同的执行路径叫做线程。

package com.learn.thread.first;

import java.util.concurrent.TimeUnit;

/**
 * 认识线程
 */
public class TestThread {
    private static class T extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MICROSECONDS.sleep(1);
                }catch (InterruptedException ex) {

                }
                System.out.println("T1");
            }
        }
    }

    public static void main(String[] args) {
        // 开启一个线程去执行
        new T().start();
        for (int i = 0; i < 10; i++) {
            try {
                TimeUnit.MICROSECONDS.sleep(1);
            }catch (InterruptedException ex) {

            }
            System.out.println("main");
        }
    }
}

在这里插入图片描述
观察上面程序的结果，你会发现T1和main交替输出，这就是程序中两条不同的执行路径在交叉执行。

创建线程的几种方式

package com.learn.thread.first;

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

/**
 * 创建线程的三种方式
 */
public class CreateThread {

    private static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Hello MyThread");
        }
    }

    private static class MyRunnable implements Runnable {
        public void run() {
            System.out.println("Hello myRunnable");
        }
    }

    private static class MyCallable implements Callable<String> {
         public String call() throws Exception {
             System.out.println("Hello MyCallable");
             return "success";
         }
    }

    public static void main(String[] args) {
        // 执行线程的五种方法
        new MyThread().start();
        new Thread(new MyRunnable()).start();
        new Thread(() -> System.out.println("hello lamdba")).start();
        new Thread(new FutureTask<String>(new MyCallable())).start();
        ExecutorService service = Executors.newFixedThreadPool(4);
        service.execute(() -> System.out.println("hello ThreadPool"));
        service.shutdown();
    }
}

分享一道面试题
启动线程的三种方式

  1. new Thread().start()
  2. new Thread(new Runnable()).start()
  3. 线程池fututreTask 或者 callable

认识几个线程的方法

sleep

sleep的意思就是说睡眠，当前线程暂停一段时候让给别的线程去执行。Sleep是怎么复活的由你的睡眠时间而定，等睡眠到了规定时间就自动恢复。

    public static void testSleep() {
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("A" + i);
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

Yield

Yield就是当前线程正在执行的时候停止下来进入等待队列，回到等待队里里在系统的调度算法里还是有可能可能吧你刚回去的这个线程拿回来继续执行，当然，更大的可能性是把原来等待的线程拿出一个来执行，所以yield的意思就是我让出一下CPU，不管别的线程是否能够抢到。

 public static void testYield() {
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("A" + i);
                if (i % 10 == 0) {
                    Thread.yield();
                }
            }
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("B" + i);
                if (i % 10 == 0) {
                    Thread.yield();
                }
            }
        }).start();
    }

Join

join的意思就是在自己当前线程加入你调用join的线程，本线程等待，等调用的线程执行完了，自己再去执行。比如 t1和t2两个线程，t1在某个点上调用了t2.join，它就会跑到t2去执行，t1等待t2运行完毕继续t1运行，但是如果是自己的join则没有任务意义。

 public static void testJoin() {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("A" + i);
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 100; i++) {
                System.out.println("B" + i);
            }
        });
        t1.start();
        t2.start();
    }

线程状态

  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
  2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
    线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
  3. 阻塞(BLOCKED)：表示线程阻塞于锁。
  4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
  5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
  6. 终止(TERMINATED)：表示该线程已经执行完毕。

在这里插入图片描述

当我们new一个线程时，还没有调用start，该线程就处于**（1）NEW新建状态。
线程对象调用start方法时候，它就会被线程调度器来执行，也就是交给操作系统来执行了，那么操作系统来执行的时候，这整个的状态就（2）Runnable运行状态**，Runnable内部有两个状态(Ready/Running)，Ready状态就是说扔到CPU的等待队列排队等待CPU运行，等CPU真正执行了才叫Running状态。注意这里调用yield时候会从Running状态跑到Ready状态
如果你的线程顺利执行完了就会进去**（3）Teminated结束状态**，注意这里是终态，不可以从new状态再调用start，这是不行的。
在Runnable这个状态还有其他一些状态的变迁**（4）TimedWaiting等待**，（5）Waiting等待，（6）Blocked阻塞,在同步代码块的情况下没得到锁就进入阻塞状态，获得锁就是就绪状态。在运行时候如果调用了o.wait、t.join、LockSupport.park就进入Waiting状态，需要调用o.noifty、o.noiftyAll、LockSupport.unpark就回到Runnning状态。TimedWaiting按时间等待等时间结束了，自己就回去了。
下面我们验证一下

package com.learn.thread.first;

public class ThreadStatus {
    static class Mythrad extends Thread {
        @Override
        public void run() {
            System.out.println(this.getState());
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                }catch (Exception ex) {
                    ex.printStackTrace();
                }
                System.out.println(i);
            }
        }
    }

    public static void main(String[] args) {
        Thread t = new Mythrad();
        System.out.println(t.getState());
        t.start();
        System.out.println(t.getState());
        try {
            t.join();
        }catch (Exception ex) {
            ex.printStackTrace();
        }
        System.out.println(t.getState());
    }

}

在这里插入图片描述

面试题1 哪些是JVM管理的？哪些是操作系统管理的？
上面的这些状态全是由JVM管理的，因为JVM管理的时候也要通过操作系统，所以JVM和操作系统是分不开的。
面试题2 线程什么状态会被挂起，挂起时候也是一个状态？
Running的时候，一个cpu上会跑多个线程，cpu会隔一段时候去执行这个线程一下，隔一段时间去执行另外一个线程一下，这个是CPU内部的一个调度。把Running状态扔回到Ready状态就叫挂起。

Synchronized

下面我们来讲synchronized关键字，先想一下为什么要上锁，如果访问一段代码或者临界资源的时候是需要一把锁的概念在这。
比如：我们读一个数字做递增，两个线程对它一块进行递增，如果两个线程共同访问的时候，第一个线程读它是0，然后把自己加1，但是如果线程没有往内存写回去的时候，第二个线程过来读，读到的是0，结果两个线程的递增，本来增加了两次，但是结果还是1。这里就用到了锁的概念，线程对这个数字的访问时独占的，不允许别的线程线程来进行计算。

先来看看线程锁程序

package com.learn.thread.first;

public class SynchronizedTest {

    private static int count = 1;

    private static Object o = new Object();

    public static void m() {
        synchronized (o) {
            if (count > 0) {
                count --;
            }
            System.out.println(Thread.currentThread().getName() + "count = " + count);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i< 100; i ++) {
            new Thread(() -> {
                SynchronizedTest.m();
            }).start();
        }
    }
}
/**
     * 这里的效果和m3的效果是一样的
     */
    public void m2() {
        synchronized (this) {
            if (count > 0) {
                count --;
            }
            System.out.println(Thread.currentThread().getName() + "count = " + count);
        }
    }

    /**
     * 这里的m2是一样的
     */
    public synchronized void m3() {
        if (count > 0) {
            count -- ;
        }
        System.out.println(Thread.currentThread().getName() + "count = " + count);

    }

    public void m4() {
        synchronized (SynchronizedTest.class) {
            if (count > 0) {
                count -- ;
            }
            System.out.println(Thread.currentThread().getName() + "count = " + count);

        }

    }

    public static void m5() {
        synchronized (SynchronizedTest.class) {
            if (count > 0) {
                count -- ;
            }
            System.out.println(Thread.currentThread().getName() + "count = " + count);

        }

    }
    //    这种方式不可行
//    public static void mmm() {
//        synchronized (this) {
//            count --;
//            System.out.println(Thread.currentThread().getName() + " count = " + count);
//        }
//    }

面试题1： T.class是单例的吗？
一个Class load到内存是不是单例的，一般情况下是，如果是在同一个ClassLoder空间，那它一定是，不是同一个类加载器就不是了，不同的类加载器互相不能访问，所以说能访问它，就一定是单例！

我们再来看看一个很有可能读不到别的线程修改过内容的程序

package com.learn.thread.first;

public class Account {
    String name;

    double blance;

    public synchronized void setBlacne(String name, double blance) {
        this.name = name;

        try {
            Thread.sleep(2000);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        this.blance = blance;
    }


    /**
     *
     * 不加锁，产生脏读现象
     * @param name
     * @return
     */
    public double getBlance(String name) {
        return this.blance;
    }

    /**
     *
     * 不加锁，产生脏读现象
     * @param name
     * @return
     */
    public synchronized double getBlanceSync(String name) {
        return this.blance;
    }

    public static void main(String[] args) {
        Account account = new Account();

        new Thread(() -> {
            account.setBlacne("zlx",100.0);
        }).start();
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBlance("zlx"));
        try {
            Thread.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBlanceSync("zlx"));
    }
}

在这里插入图片描述
如图所述，当用getBlance获取的时候，产生了脏读现象，是因为setBlance睡了1000加锁,getBlance是没加锁的，所以异步的时候，获取的blance是0，但是getBlanceSync也是加锁的，锁的也是当前对象，所以不会产生脏读。

可重入

synchronized是可重入的，有一个方法m1是synchronized,另外一个方法m2也是synchronized，我们在m2开始的时候获取到了这把锁，然后m1里面调用m2，如果说这个时候不允许任务线程再来获取锁，就会造成死锁，锁以m2也需要申请锁，它发现同一个线程已经申请到了锁，也就让m2继续运行了，这就叫可重入锁。

嵌套锁

package com.learn.thread.first;

public class T {
    private static int count = 10;

    /**
     * 一个同步方法调用另外一个同步方法，一个线程已经拥有了某个对象的锁，该线程再次申请的时候仍然会得到该对象的锁
     * 这就是可重入
     *
     * 这里我们模拟减两次
     */
    public synchronized static void m1() {
        count --;
        System.out.println("m1 " + Thread.currentThread().getName() + " count = " + count);
        m2();
    }
    public synchronized static void m2() {
        count --;
        System.out.println("m2 " + Thread.currentThread().getName() + " count = " + count);
    }
    


    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> T.m1()).start();

        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里我们模拟一个父类子类的概念，父类的方法synchronized，子类调用super.m的时候必须得可重入，否则就会出现问题，调用父类是同一把锁，所谓的可重入锁就是你拿到这个锁以后不停的加锁加锁，加好几道，但是加的锁都是同一个对象，去一道就减1。

父子锁


    static class TT extends T {
        @Override
        public synchronized void m1() {
            count --;
            System.out.println("m1 son " + Thread.currentThread().getName() + " count = " + count);
            super.m1();
        }
    }

异常锁

我们来看看异常锁的情况，加一个while(true)循环，当等于15的时候产生异常，我们看看如果这个时候产生异常，会出现什么情况？

    /**
     * 程序在执行过程中，如果出现异常，默认情况下锁会被释放
     * 所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况下
     * 比如 一个webapp处理过程中，多个请求实例共同访问同一个资源，这时如果异常处理不合适
     * 在第一个县城中抛出异常，其他线程就会进入同步代码块，有可能会访问到异常产生时的数据
     *
     */
    public synchronized void m3() {
        System.out.println(Thread.currentThread().getName() + "start");
        while (true) {
            count ++;
            System.out.println(Thread.currentThread().getName() + "count = " + count);
            try {
                TimeUnit.SECONDS.sleep(1);
            }catch (Exception ex) {
                ex.printStackTrace();
            }
            if (count ==  15) {
                // 这里产生异常，锁被释放，如果想不被释放，可以在这里进行catch，然后让循环继续
                int i = 1/0;
                System.out.println(i);
            }
        }

    }

线程2 开始之后居然打印了线程1的异常信息
在这里插入图片描述

synchronized的底层实现

早期时候的java的synchronized底层实现时重量级的，需要找操作系统去申请锁，就会造成效率非常低下，java后来进行了锁升级
从原来都去找操作系统，现在是线程进来之后先去访问锁对象，在这个锁对象的对象头记录一下这个线程的ID，如果这个锁对象存在多个线程ID，那么就升级为自旋锁，概念就是不会跑到cpu的就绪队列取等待执行，而是用一个while循环，相当于一个插队的概念，如果循环十几次都没有拿到锁，就升级为重量级锁，去操作系统请求申请这个锁对象。
执行时间短（加锁代码），线程数少，用自旋锁
执行时间长，线程数多，去操作系统申请锁

至于锁升级的详细过程，以后更新

zglx123
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
并发和并行及多线程基本概念
zhaohong_bo的专栏
04-11 2296
并发 并行 同步 异步 多线程
多线程与高并发实战手册.rar
03-20
在IT领域，多线程和高并发是两个关键的概念，特别是在服务器端开发、分布式系统以及高性能计算中。本文将基于《多线程与高并发实战手册》中的知识点，深入探讨这两个主题。 首先，多线程是指在一个程序中同时运行多...
[并发概念] 多线程与高并发
大唐雨夜的博客
12-31 1563
多线程的理解 什么是多线程 如果一个程序允许两个或者两个以上的线程，那么它便是多线程程序。多线程是指单个进程内允许多个线程。 任务分为资源独立任务和资源共享任务。独立任务不需要使用多线程；共享任务，会使用到进程共享资源，需要保证线程安全。 场景理解：房子与租客 假设有一套房子，住着我和我的几个室友，房子比喻进程，我和室友比喻线程。房子中有很多公共空间，例如厨房、客厅，每个人都可以到客厅来。厨房和客...
多线程与高并发整理总结【超全面】
认知 行动 坚持
11-22 2559
我们先说一下为什么要讲多线程和高并发？ 原因是，你想拿到一个更高的薪水，在面试的时候呈现出了两个方向的现象： 第一个上天 项目经验 高并发、缓存、大流量、大数据量的架构设计 第二个入地 各种基础算法，各种基础的数据结构 JVM OS线程、IO等内容 多线程和高并发，就是入地里面的内容。 一、基本概念 我们先从线程的基本概念开始，给大家复习一下。如果基础不太好，说什么是线程都不知道的，则需要花时间去补初级内容的课。 1. 什么是进程？什么是线程？ Program app，比如QQ.exe
多线程与高并发基本概念
吃四碗饭的嘤嘤怪的博客
07-26 1万+
1.同步（Synchronous）与异步（Asynchronous） 同步和异步通常形容一次方法的调用。同步方法调用开始后调用者必须等到方法调用返回才能进行后续行为。异步方法则像一个消息的传递，调用方法后立即返回而方法体则在后台继续运行，调用者无需等待继续后续操作。 2.并发（Concurrency）和并行（Parallelism） 并发和并行都能表示两个或多个任务一起执...
多线程与高并发笔记
牧小农
09-13 3926
1. 创建线程的三种方式 实现Runnable 重写run方法 继承Thread 重写run方法 线程池创建 Executors.newCachedThreadPool() 2. Thread线程操作方法 Thread.sleep([mills]) 当前线程睡眠指定mills毫秒 Thread.yield() 当前线程优雅让出执行权 join 例如Thread t1, t2 在t2的run方法中调用t1.join(),线程t2将等待t1完成后执行 3. Thread状态
Python中的并发编程：多线程与多进程的比较
一键难忘的博客
03-11 3706
在Python编程领域中，处理并发任务是提高程序性能的关键之一。本文将探讨Python中两种常见的并发编程方式：多线程和多进程，并比较它们的优劣之处。通过代码实例和详细的解析，我们将深入了解这两种方法的适用场景和潜在问题。
C++11多线程第一篇:并发基本概念及实现，进程、线程基本概念
森明帮大于黑虎帮的博客
10-23 2325
C++11多线程第一篇:并发基本概念及实现，进程、线程基本概念
Python多线程与高并发
you are sherlocked by me!
02-28 1万+
主要讲解了关于Python多线程的一些例子和高并发的一些应用场景# -*- coding: utf-8 -*- # @Author: Clarence # @Date: 2018-02-28 20:39:31 # @Last Modified by: Clarence # @Last Modified time: 2018-02-28 23:29:54 """ 涉及知识点 互斥锁 线程 在...
多线程和高并发介绍
热门推荐
穿越清华
06-06 3万+
多线程和高并发介绍 文章目录多线程和高并发介绍前言一、什么是多线程？1.多线程介绍2.多线程实现原理？3.白话文解释多线程4.多线程存在的问题二、什么是高并发?1.高并发介绍2.如何提升系统的并发能力三、多线程和高并发总结 前言 本文主要是针对多线程和高并发的概念做了简单的描述，介绍了什么是多线程，什么是高并发，并且对多线程和高并发的关系做了比较描述。 一、什么是多线程？ 1.多线程介绍 什么是多线程，首先看下百度百科对多线程的定义；多线程（multithreading）
高并发与多线程的关系与区别
weixin_48358336的博客
09-22 2809
一、什么是高并发        高并发（High Concurrency）是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况，主要发生在web系统集中大量访问收到大量请求（例如：12306的抢票情况；天猫双十一活动）。该情况的发生会导致系统在这段时间内执行大量操作，例如对资源的请求、数据库的操作等。 二、高并发的处理指标 高并发相关常用的一些指标有：响应时...
多线程与高并发编程笔记、源码等
09-05
标题“多线程与高并发编程笔记、源码等”表明了资源的核心内容，涵盖了多线程和高并发编程的理论与实践。多线程允许一个应用程序同时执行多个任务，而高并发则指系统能够处理大量并发请求的能力。这两个概念在现代...
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
在IT领域，尤其是在人工智能（AI）的项目实践中，多线程和高并发是两个至关重要的概念，它们对于提升系统性能和处理大规模数据流至关重要。在这个名为"人工智能-项目实践-多线程-多线程与高并发.zip"的压缩包中，...
Java常见面试题之多线程和高并发详解
08-26
Java多线程和高并发面试题详解 Java多线程和高并发面试题是Java开发者面试时经常遇到的问题，本文将详细介绍Java多线程和高并发相关知识点，通过示例代码对大家进行了详细的介绍，对大家学习或者使用Java具有很高的...
Java多线程与高并发入门到精通-视频教程网盘链接提取码下载.txt
09-08
学习者将从入门到精通，掌握多线程的概念、原理和常用技术，学会如何编写高效、安全、可靠的多线程应用程序，以及解决高并发场景下的各种问题。通过实践项目和案例分析，帮助学员深入理解多线程编程的核心思想和技巧...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 452
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 251
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 622
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 283
集合之Map
Java多线程与并发库高级技术解析
"张孝祥的Java多线程与并发库高级应用笔记涵盖了从传统线程技术到Java 5引入的并发库的广泛内容，旨在帮助已有基础的开发者提升Java线程技术。教程通过深入讲解各种线程同步和通信机制，如线程互斥、同步通信、共享...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值