多线程（单核cpu宏观上并行，微观上串行）

最新推荐文章于 2023-09-03 01:15:39 发布
最新推荐文章于 2023-09-03 01:15:39 发布
阅读量2k 收藏 1
点赞数 3
分类专栏： javaee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwf0615/article/details/109170678
版权

多线程（单核cpu宏观上并行，微观上串行）

1. 线程状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oeQZgwRP-1603117044712)(C:\Users\lwf\AppData\Roaming\Typora\typora-user-images\image-20201019213747706.png)]

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

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

一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

2. 线程与进程

  • 线程：cup执行与调度的最小单位
  • 进程：计算机资源分配的单位
  • 联系：进程由一个或多个线程组成

3. 线程的实现方式

  • 继承Thread类，重写run()方法

    ``

    package com.lwf.ThreadLearn;

/**
 * @author lwf
 * @title: SynTest
 * @projectName 10_19Code
 * @description: 同步锁资源
 * @date 2020/10/1916:44
 */
public class SynTest extends Thread{
        private static  Tick ticks=new Tick();//锁资源
        public SynTest(String name, Tick ticks) {
            super(name);
            this.ticks=ticks;
        }

        public SynTest() {
            super();
        }

        public SynTest(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (true){
                synchronized (ticks) {//锁资源
                    if(ticks.num>0){
                        System.out.println(this.getName()+"买第"+ticks.num);
                         ticks.num--;
                    }
                    else
                        return;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public static void main(String[] args) {
            Tick ticks=new Tick();
            ticks.num=100;
            //抢票1
            SynTest ticks1=new SynTest("吴彦祖",ticks);
            SynTest ticks2=new SynTest("罗卫飞");
            SynTest ticks3=new SynTest("永日");
            ticks1.start();
            ticks2.start();
            ticks3.start();
        }
    }

class Tick{
    int num=100;
}

  • 实现Runable接口，实现run（）方法

    package com.lwf.ThreadLearn;

/**
 * @author lwf
 * @title: Rubbit
 * @projectName 10_19Code
 * @description: 龟兔赛跑
 * @date 2020/10/1911:10
 */
public class Rubbit implements Runnable{
    public static void main(String[] args) {
        Rubbit rubbit=new Rubbit(10, 20);
        Rubbit rubbit1=new Rubbit(3, 5);
        Thread thread=new Thread(rubbit1,"乌龟");
        Thread thread1=new Thread(rubbit,"兔子");
        thread.start();
        thread1.start();
    }
    private int all=100;
    private int speed;
    private int had=0;
    private int sleep;
    private  static boolean fin=false;
    public Rubbit(int speed,int sleep) {
        this.speed = speed;
        this.sleep=sleep;
    }

    @Override
    public void run() {
        while (true){
            synchronized (Rubbit.class) {
                if (fin) {
                    return;
                }
            }
            had += speed;
            System.out.println(Thread.currentThread().getName() + "跑了"+had+"还剩"+(all-had));
            synchronized (Rubbit.class) {
                if (had >= all) {
                    System.out.println(Thread.currentThread().getName() + "赢了");
                    fin = true;
                }
            }
            try {
                Thread.sleep(sleep);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

  • 实现Callable接口，实现call（）方法

    package com.lwf.homeWork;

import java.util.concurrent.*;

/**
 * @author lwf
 * @title: TestTwo
 * @projectName 10_19Code      同时实现Runable,CallAble接口，分别实现以下操作
 * @description: 2. 通过2个线程实现 案例:
 * 	一个线程计算1~10000之间所有素数的和
 * 	一个线程计算10000~20000之间所有素数的个数
 * 	最终打印结果
 *
 * @date 2020/10/1919:22
 */
public class TestTwo implements Runnable, Callable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestTwo testTwo = new TestTwo();
        ExecutorService pool= Executors.newFixedThreadPool(2);
        pool.submit((Runnable) testTwo);
        Future future= pool.submit((Callable<Object>) testTwo);
        pool.shutdown();
        System.out.println("素数个数"+future.get());
    }
    private int sum=5;//1~10000之间所有素数的和
    private int num=0;//10000~20000之间所有素数的个数
    public static boolean judge(int i){//素数判断
        boolean flag=true;
        for(int i1 = 2;i1<=Math.sqrt(i);i1++){
            if(i%i1==0){
                return false;
            }
        }
        return flag;
    }

    /**
     * 1~10000之间所有素数的和
     */
    @Override
    public void run() {
        for (int i=4;i<10000;i++){
            if(judge(i)){
                sum+=i;
            }
        }
        System.out.println("和："+sum);
    }

    /**
     * 10000~20000之间所有素数的个数
     * @return
     * @throws Exception
     */
    @Override
    public Object call() throws Exception {
       for(int i=10000;i<=20000;i++){
           if (judge(i)){
               num++;
           }
       }
        return num;
    }
}

  • 区别：

    实现Thread ：因为类的单继承多实现机制，这种方法灵活性较差

    实现Runable接口：这种方法，灵活性好，但是run方法不可抛出异常，这是我个人实现多线程最喜欢的方式

    实现Callable接口：这种方法灵活好，run方法可抛出异常，并且有返回值，写的时候不用抛出异常·，一般用于线程池

    4. 线程优先

    每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。

    Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。

    默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。

    具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

    5.线程方法

    序号方法描述
    1public void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
    2public void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
    3public final void setName(String name) 改变线程名称，使之与参数 name 相同。
    4public final void setPriority(int priority) 更改线程的优先级。
    5public final void setDaemon(boolean on) 将该线程标记为守护线程或用户线程。
    6public final void join(long millisec) 等待该线程终止的时间最长为 millis 毫秒。
    7public void interrupt() 中断线程。
    8public final boolean isAlive() 测试线程是否处于活动状态。

    测试线程是否处于活动状态。 上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法。

    序号方法描述
    1public static void yield() 暂停当前正在执行的线程对象，并执行其他线程。
    2public static void sleep(long millisec) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
    3public static boolean holdsLock(Object x) 当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
    4public static Thread currentThread() 返回对当前正在执行的线程对象的引用。
    5public static void dumpStack() 将当前线程的堆栈跟踪打印至标准错误流。

6.同步(数据一致性保障)

  • synchronized

    同步代码块

    同步class

    同步对象

    同步方法

  • volitite

1.主要作用：用在多线程编程时，当在jvm开启优化性能的时候，强制线程在使用volidate修饰的变量的时候，从主内存中读取，不从线程副本内存中读取变量，从而保证了变量的同步安全。

  • ReenTransLock

    lock（）和unlock（）方法对代码的访问实现同步

但许人间现白头
关注
专栏目录
JAVA 系列——>多线程（Thread ）
JAVA求生之路——博主406766467
01-18 283
我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏 边听歌，怎么设计？ 要解决上述问题,咱们得使用多进程或者多线程来解决. 并发与并行 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生（同时发生）。 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每 一时刻只...
Java多线程
ZChiChi88的博客
04-06 109
进程：程序是静止的，只有真正运行时的程序，才被称为进程。 特点： 单核CPU在任何时间点上。 只能运行一个进程。 宏观并行、微观串行。 线程：又称轻量级进程。程序中的一个顺序控制流程，同时也是CPU的基本调度单位。进程由多个线程组成，彼此间完成不同的工作，交替执行，称为多线程。 线程和进程的区别 进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位。 一个程序运行后至少有一个进程。 一个进程可以包含多个线程，但是至少需要有一个线程。 进程间不能共享数据段地址，但同进程的线程之间可以。 线程的组
一种实现微观单线程，宏观上多线程的方法
Virgo的博客
08-06 3352
1. 纵所周知的是，C语言是顺序程序设计的，那么在一些MCU中，例如STM32，Atmega168等等，在微观上程序都是单线程的，那么应该如何实现微观上的多线程呢？这个用到两个东西：一是中断，二是switch语句。听老夫为你细细道来。   2. 举个例子来说，比如我想要实现的是：MCU每2秒通过6个USART向外发送数据。一般大家首先想到的是，配置一个定时器，每2S进入一个中断函数，然后中...
[操作系统] 多道批处理系统宏观上并行微观上串行的含义
PriceCheap的博客
06-13 1450
多道批处理系统宏观上并行微观上串行的含义:宏观上不同程序，不同设备并行，微观上同一设备串行王道里面并没有详细解释看题目更容易理解时间轴中不同程序为不同行，不同设备可以在时间轴的相同坐标，也就是 宏观上不同程序，不同设备并行 同一设备不可以在时间轴的相同坐标，也就是 微观上同一设备串行...
pythonthread锁对象
weixin_34363171的博客
09-15 164
#!/usr/bin/env pythonimport threadfrom time import sleep, ctimeloops = [4,2]def loop(nloop, nsec, lock): print 'start loop', nloop, 'at:', ctime()打印开始nloop 创建时间 sleep(nsec)休眠时间 print 'lo...
python 对象锁_GIL 将死，Python 当兴？！
weixin_39562606的博客
11-27 106
英文 | Has the Python GIL been slain?【1】作者 | Anthony Shaw译者 | 豌豆花下猫@Python 猫公众号声明 ：本文获得原作者授权翻译，转载请保留原文出处，请勿用于商业或非法用途。2003 年初，Intel 公司推出了全新的奔腾 4 "HT" 处理器，该处理器的主频(译注：CPU 内核工作的时钟频率)为 3 GHz，采用了"超线程"技术。在接下来的...
多线程的宏观和微观视角
lantao
08-14 419
首先我们在做并发编程的的时候会考虑到原子性丶可见性和有序性，在宏观上会考虑到安全性丶活跃性和性能； 微观视角 可见性: 一个线程对共享变量的修改，另外一个线程能够立刻感知到，我们称为可见性; 原子性： 一个或者多个操作在 CPU 执行的过程中不被中断的特性称为原子性； 有序性： 就是我们代码的执行顺序，依赖等。(指令重排导致顺序被打乱);   线程工作内存： 是指 Cpu 的 ‘寄存器’ ...
单核CPU,多线程与性能
fangpeiliang的专栏
08-26 530
问题概述单核CPU的计算机上, 多线程能够提高程序运行的性能吗? 这个问题看起来简单,实际很复杂,设计到多方面的因素. 首先我们要把概念搞清楚, 那就是什么是性能? 一般来说, 我们把运行一个任务所花的时间来评价性能, 所花的时间可以是在CPU上, 也可能是在I/O操作上, 运行任务的程序, 也可能同时在运行另外若干的任务(吞吐量). 这里我们把概念给缩小一下: 我们这里把性能限制在一
漫道多线程(一):多线程与并行计算简述
qq_35824590的博客
01-04 2219
漫道多线程(一):多线程与并行计算简述 文章目录漫道多线程(一):多线程与并行计算简述什么是并行计算什么是多线程并行计算的好处1.硬件上的迫切需要2.更好的提升资源利用率为什么要使用多线程实现并行计算CPU时间分片并行与并发并发并行如何在java中使用多线程继承Thread类实现Runable接口(java8的Lambda可以轻松实现)java线程模型以及编写多线程代码会面临的问题如何解决多线程 并发中数据不一致的问题设计上如何避免使用锁保护脆弱的数据synchronized锁volatile锁原子类锁 什
并发与并行
一颗哈士奇的博客
06-07 477
一、什么是并发与并行 并行的意思是：同时进行；串行是一个一个进行。 并发与并行的区别： 并发：宏观上并行（即给人的感觉是同时进行的），微观（实际）上是串行的； 并行：宏观上并行（即给人的感觉是同时进行的），微观（实际）上也是并行。 两者在宏观上给人的感觉都是在同时进行，然而本质上两者存在很大的区别。 1. 并发在微观上的表现是串行的，在同一个CPU的同一核中交叉式地处理线程，而不是同时处理多个线程...
java多线程
qq_42211758的博客
03-16 234
知识点–并发与并行 目标 能够理解什么是并发和并行 路径 并行的概述 并发的概述 讲解 并行：指两个或多个事件在同一时刻发生（同时执行）。 并发：指两个或多个事件在同一个时间段内发生(交替执行)。 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个
Python简单进程锁代码实例
09-22
主要介绍了Python简单进程锁代码实例,本文讲解了线程和进程的相关知识,然后给出了Python的实现代码,需要的朋友可以参考下
JAVA随笔
一个技术菜鸟的博客
09-03 206
参考：http://blog.csdn.net/anxpp/article/details/51325838 一句话：命长的对象持有短命对象，可能会出现内存泄露。 我们举一个简单的例子： public class Simple { Object object; public void method1(){ object = new Object(); //...其他代码 } } 这里的object实例，其实我们期望它只作用于method1()方法中，
OS中了解“并发”与“并行”的区别和“宏观上并发，微观上交替执行”
MoMing丶的博客
02-23 3657
“并发”与“并行”的区别 并发 指两个或多个事件在同一时间间隔内发生，看似都在向前推进； 在微观上不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。 从宏观外来看，好像是这些进程都在执行。 并行 指两个或多个事件在同一时刻在不同的物理设备上发生； 无论在微观还是宏观上都是在同时进行。 每个事件在同一时刻真正的同时进行。 在单CPU下，微观上多个程序是不可能同时进行的； ...
线程的生命周期
weixin_42596738的博客
10-15 89
JDK中用Thread.state类中定义了线程的几种状态 要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在他的一个完整的声明周期中通常要经历如下的五种状态： 新建：当一个Thread类及其子类的对象被声明并创建时，新生的线程对象处于新建状态 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源 运行：当就绪的线程被调度并获取CPU资源时，便进入运行状态， run()方法中定义
python通信_Python通过4种方式实现进程数据通信
weixin_39894473的博客
11-23 553
python提供了4种方式来满足进程间的数据通信1. 使用multiprocessing.Queue可以在进程间通信,但不能在Pool池创建的进程间进行通信2. 使用multiprocessing.Manager.Queue可以在Pool进程池创建的进程间进行通信3. 通过Pipe进行线程间的通信, pipe进程间通信的性能高于Queue,但是它只能在两个进程间进行通信4. 使用Manager类提...
5 分钟完全掌握 Python 协程
Python中文社区
12-16 196
1. 协程相关的概念1.1 进程和线程进程（Process）是应用程序启动的实例，拥有代码、数据和文件和独立的内存空间，是操作系统最小资源管理单元。每个进程下面有一个或者多个线程（Thr...
Python 中的锁对象——线程同步
最新发布
很酷的站长的博客
09-03 136
在多线程中，当多个线程同时处理一个共享资源(如文件)时(向文件中读写数据)，为了避免并发修改错误(多个线程访问同一资源导致数据不一致)，使用了某种锁定机制，当一个线程访问一个资源时，它会锁定该资源，直到它释放该锁定，其他线程都不能访问同一资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值