多线程概述

最新推荐文章于 2022-09-04 17:24:10 发布
最新推荐文章于 2022-09-04 17:24:10 发布
阅读量563 收藏
点赞数
分类专栏： JAVA 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44890539/article/details/105015402
版权

1 多线程

多线程:是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能

1.1 并发与并行

  • 并行：指两个或多个事件在同一时刻发生（同时执行）。
  • 并发：指两个或多个事件在同一个时间段内发生(交替执行)。

在这里插入图片描述

1.2 线程与进程

  • 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
  • 线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

进程与线程的区别

  • 进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
  • 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。

线程调度:

  • 分时调度:所有线程轮流使用 CPU使用权,平均分配每个线程占用CPU的时间.
  • 抢占式调度:
    优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

1.3 Thread类

Thread作为线程开启,在线程的调度中必须要用到Thread

来看一下构造方法都有哪些:

  • public Thread() :分配一个新的线程对象。
  • public Thread(String name) :分配一个指定名字的新的线程对象。
  • public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
  • public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

  • public String getName() :获取当前线程名称。
  • public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
  • public void run() :此线程要执行的任务在此处定义代码。
  • public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
  • public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

创建线程的方式:

  1. 继承Thread类方式
  2. 是实现Runnable接口方式

1.4 创建线程方式一_继承方式

步骤:

  1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
    run()方法称为线程执行体。
  2. 创建Thread子类的实例，即创建了线程对象
  3. 调用线程对象的start()方法来启动该线程

代码演示:

	public class Demo01 { 
		public static void main(String[] args) { 
			//创建自定义线程对象 
			MyThread mt = new MyThread("新的线程！"); 
			//开启新线程 
			mt.start(); 
			//在主方法中执行for循环 
			for (int i = 0; i < 200; i++) { 
				System.out.println("main线程！"+i); 
			} 
		} 
	}

1.5 创建线程的方式二_实现方式

采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。

  1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
    的线程对象。
  3. 调用线程对象的start()方法来启动线程。
	public class MyRunnable implements Runnable{ 
		@Override public void run() { 
			for (int i = 0; i < 20; i++) {
				 System.out.println(Thread.currentThread().getName()+" "+i); 
				} 
			} 
		}

	public class Demo { 
		public static void main(String[] args) { 
			//创建自定义类对象 线程任务对象 
			MyRunnable mr = new MyRunnable(); 
			//创建线程对象 
			Thread t = new Thread(mr, "小强"); 
			t.start(); 
			for (int i = 0; i < 20; i++) { 
				System.out.println("旺财 " + i); 
			} 
		} 
	}

1.6 匿名内部类方式


/**
 * 请使用继承Thread类的方式定义一个线程类，在run()方法中循环10次，
 * 每1秒循环1次，每次循环按“yyyy-MM-dd HH:mm:ss”的格式打印当前系统时间。
 * 	请定义测试类，并定义main()方法，启动此线程，观察控制台打印。
 */
public class Demo03 {
    public static void main(String[] args) {

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Date date = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String s = sdf.format(date);
                    System.out.println(s);
                }
            }
        });
        thread.start();
    }
}

2 高并发及线程安全

  • 高并发：是指在某个时间点上，有大量的用户(线程)同时访问同一资源。例如：天猫的双11购物节、12306的在线购票在某个时间点上，都会面临大量用户同时抢购同一件商品/车票的情况。
  • 线程安全：在某个时间点上，当大量用户(线程)访问同一资源时，由于多线程运行机制的原因，可能会导致被访问的资源出现"数据污染"的问题。

2、1 多线程的安全性问题-可见性

Thread线程:


public class Thread extends java.lang.Thread {
    public static int a = 0;

    @Override
    public void run() {
        System.out.println("Thread0线程开始运行");

        System.out.println("将a的值变成1");
        a = 1;
        System.out.println("改变成功!!");

    }
}

测试类:


public class Test {
    public static void main(String[] args) {
        //创建子类对象
        Thread thread = new Thread();
        //调用start方法,运行run方法
        thread.start();

        while (true){
            /**
             * 可见性问题:由于while循环的速度太快,一直获取的是主内存中(也就是自己的内存空间)的a=0;
             * 所以,死循环就一直执行下去了,
             * 解决这个问题有两种方案:
             * 方案1:在while循环里面让while循环睡两秒,降低循环效率
             * 方案2:在Thread中添加变量修饰符;volatile
             */

            if(Thread.a == 1){
                System.out.println("main线程,判断a的值是否为1,结束循环");
                break;
            }
        }

    }
}

2、2 多线程的安全性问题-有序性

  • 有些时候“编译器”在编译代码时，会对代码进行“重排”，例如：
    int a = 10; //1
    int b = 20; //2
    int c = a + b; //3
    第一行和第二行可能会被“重排”：可能先编译第二行，再编译第一行，总之在执行第三行之前，会将1,2编译完毕。1和2先编译谁，不影响第三行的结果。

但在“多线程”情况下，代码重排，可能会对另一个线程访问的结果产生影响：

2、2 多线程的安全性问题-原子性

Thread线程:


public class MyThread extends Thread {
    public static int a = 0;
    @Override
    public void run() {
        System.out.println("线程开始,打印a的值");
        for (int i = 0; i < 10000; i++) {
            a++;
        }
        System.out.println("改变完成");
    }
}

测试类:


public class Test {
    public static void main(String[] args) {
        //创建对象
        MyThread thread = new MyThread();
        thread.start();

        System.out.println("主线程开始执行:");
        System.out.println("开始改变a的值");
        for (int i = 0; i < 10000; i++) {
            MyThread.a++;
        }
        /**
         * 最终结论:
         *  得到a的值可能不是20000,会少很多
         *  每个线程访问money变量，都需要三步：
         * 	1).取money的值；
         * 	2).将money++
         * 	3).将money写回
         * 这三步就不具有“原子性”——执行某一步时，很可能会被暂停，执行另外一个线程，就会导致变量的最终结果错误！！！！
         */

        //先睡1秒,先让Thread线程执行完
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程改变a完成");
        System.out.println(MyThread.a);
    }
}

3 volatile关键字

  • volatile是一个"变量修饰符"，它只能修饰"成员变量"，它能强制线程每次从主内存获取值，并能保证此变量不会被编译器优化。
  • volatile能解决变量的可见性、有序性；
  • volatile不能解决变量的原子性

3.1 volatile解决可见性


public class Thread extends java.lang.Thread {
    public static volatile int a = 0;

    @Override
    public void run() {
        System.out.println("Thread0线程开始运行");

        System.out.println("将a的值变成1");
        a = 1;
        System.out.println("改变成功!!");

    }
}



public class Test {
    public static void main(String[] args) {
        //创建子类对象
        Thread thread = new Thread();
        //调用start方法,运行run方法
        thread.start();

        while (true){

            if(Thread.a == 1){
                System.out.println("main线程,判断a的值是否为1,结束循环");
                break;
            }
        }

    }
}

注意:volatile关键字只能解决"变量"的可见性、有序性问题，并不能解决原子性问题

奥申
关注
专栏目录
多线程详解（一）——创建多线程
weixin_43912697的博客
02-18 987
一. 进程与线程： 1. 进程： 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。 2. 线程： 线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。
C++11多线程编程 一：多线程概述
qq_34761779的博客
02-25 902
一：多线程概述
多线程的创建方法
qq_54500361的博客
10-24 209
多线程 概念： 程序： 程序是指令和数据的有序集合，静态的代码 进程： 是执行程序的一次执行过程，它是一个动态的概念。是操作系统分配资源的单位 线程： CPU调度和执行的单位，独立执行的路径。互不影响，线程的执行由调度器安排，对同一资源进行操作时，需要并发控制 . 创建多线程 自定义线程类继承Thread类 重写run()方法，编写线程执行体 创建线程对象，调用start()方法启动线程 创建线程方式一： 继承Thread类，重写run()方法，调用start开始线程 //创建线程方式一：继承Threa
【java基础之多线程】多线程的创建
Cherie
08-31 709
继承 java.lang.Thread 类 步骤： 1）定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。（把 run() 方法称为线程执行体） 2）创建Thread子类的实例，即创建了线程对象 3）调用线程对象的 start() 方法来启动线程 PS：使用继承Thread类的方法来创建线程类时，多个线程间无法共享线程类的实例变量 实现 java.lang.Runnable 接口
java 守护线程
weixin_40426261的博客
11-11 125
test01
创建多线程程序
qq_50542009的博客
06-14 2159
创建多线程程序的第一种方式:创建Thread类的子类 java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类实现步骤: 1.创建一个Thread类的子类 2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)3.创建Thread类的子类对象 4.调用Thread类中的方法start方法,开启新的线程,执行run方法 void start()使该线程开始执行;Java虚拟机调用该线程的run方法。 结果是两个线程并发地运行
多线程概述、简介及应用详解.pdf
05-15
### 多线程概述、简介及应用详解 #### 一、多线程概述 多线程（Multithreading）作为一种重要的并发编程技术，其核心在于允许多个独立的任务或操作在同一个进程中并行执行。这一特性使计算机系统能更有效地利用...
15.多线程概述一（下篇）
最新发布
09-21
15.多线程概述一（下篇）
Java程序基础-多线程概述.pptx
09-15
Java程序基础中的多线程是Java编程中一个重要的概念，特别是在构建高效并发应用程序时不可或缺。在Java中，多线程允许程序同时执行多个任务，从而提高计算机系统的利用率和响应速度。 1. **线程与进程**： - **...
多线程的创建(超详解）
qq_46804966的博客
05-09 1100
文章目录1.线程创建的三种方式1.1继承Thread类1.2实现Runnable接口1.3实现Callable接口1.4三种方式比较2.线程分组3.Thread类及常见方法3.1Thread类的常见构造方法3.2Thread类的常见属性3.2.1线程优先级3.2.2线程分类3.2.3线程练习3.3启动一个线程-start( )3.4中断一个线程-interrupt（）3.5等待一个线程-join（）3.6获得当前线程引用3.7线程休眠4.线程的状态4.1线程的所有状态4.2线程状态图4.3yield（）方法
多线程创建的几种方法
m0_67463092的博客
03-30 1339
一.利用一个继承于Thread类的子类来实现 1.创建一个继承于Thread类的子类 2.重写Thread类中的run（）方法，run方法中是此线程将要执行的操作 3.在main方法中创建Thread类的子类对象 4.通过此对象调用start（）方法 （start方法就是启动当前线程，调用当前线程的run方法） 二.利用Runnable接口的方式去实现 1创建一个实现Runnable接口的类 2.实现类中的run（）方法 3.创建类的对象 4.将此对象作为参数传递到Thread类的构造器
多线程的创建
遇安的博客
04-23 2741
创建方式一：继承Thread类创建多线程 public class 多线程_1创建 { public static void main(String[] args) { //创建方式一 Thread t=new MyThread();//创建MyThread线程对象 //直接调run()方法会被当成普通方法执行，此时相当于还是单线程执行， // 所以需要调用start()方法启动多线程 t.start();//调.
第一章 线程
qq_39354297的博客
09-08 368
第一章 线程 1.1 多线程原理 画一个多线程执行时序图来体现一下多线程程序的执行流程。代码如下：自定义线程类： 1 public class MyThread extends Thread { 2 /* 3 * 利用继承中的特点 4 * 将线程名称传递 进行设置 5 */ 6 ...
学习多线程，创建多线程的三种方式
weixin_45627271的博客
09-04 1710
学习多线程，创建多线程的三种方式
【Java多线程系列】经典面试题：使用多线程，循环10次并按顺序打印出ABC
Yangy的博客
10-24 2598
目录 1.前言 问题点分析： 2.上才艺 2.1 方式一：使用AtomicInteger 2.2 方式二：使用线程池newSingleThreadExecutor 2.3 方式三：使用join 2.4 方式四：使用CyclicBarrier 3.总结 1.前言 前段时间，有个同事朋友出去面试，遇到一个有意思的面试题，内容如下： 现有3个线程（命名为T1,T2,T3,后续内容以此描述进行），线程1能打印输出字母A;线程2能打印输出字母B;线程1能打印输出字母C; 要求，循环10次，使
Java中多线程创建方式
weixin_49772216的博客
05-29 132
多线程的基本概论： 1.程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。 2.进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 3.线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一时
JAVA【10】 线程
qq_1595986877
07-29 1325
一、线程引入 1、并行与并发 2、进程和线程 进程： 具有一定独立功能的程序关于某个数据集合上的一次运行活动，是操作系统进行资源分配和调度的一个独立单位。 线程： 是进程的一个实体，是 cpu 调度和分派的基本单位，是比进程更小的可以独立运行的基本单位。 特点： 线程的划分尺度小于进程，这使多线程程序拥有高并发性， 进程在运行时各自内存单元相互独立，线程之间内存共享， 这使多线程编程可以拥有更好的性能和用户体验 注意：多线程编程对于其它程序是不友好的，占据大量 cpu 资源。 3、主线程 主线
多线程基础
m0_54108654的博客
04-16 805
目录 一 线程相关概念 1 程序 2 进程 3 线程 4 单线程 5 多线程 6 并发——交替运行 7 并行——同时运行 二 线程的基本使用 1 创建线程的两种方式 2 线程应用案例1—继承Thread类 3 线程应用案例2—实现Runnable接口 4 线程应用案例3——多线程执行 5 两种创建线程方式的区别 一 线程相关概念 1 程序 定义：是为了完成特定任务，用某种语言编写的一组指令集合 简单的说：就是我们些的代码 2 进程 21 进程就是运行的程序，程序一
java循环10次_Java多线程：用三个线程控制循环输出10次ABC
weixin_32021363的博客
02-23 1336
转载：http://www.cnblogs.com/gaopeng527/p/5257884.html题目：有A,B,C三个线程, A线程输出A, B线程输出B, C线程输出C，要求, 同时启动三个线程, 按顺序输出ABC, 循环10次。解题思路：要按顺序输出ABC, 循环10次，就要控制三个线程同步工作，也就是说要让三个线程轮流输出，直到10个ABC全部输出则结束线程。这里用一个Lock对象来控...
"多线程概述与实践：并发、线程状态、线程安全集合
在第10章《多线程》中，主要介绍了并发、并行、进程和线程的概念。并发指的是多个事件在同一时间段内发生，而并行指的是多个事件在同一时刻发生。在操作系统中，安装了多个程序的系统中，并行指的是宏观上有多个程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值