多线程 5 线程休眠 回顾 线程安全

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量113 收藏
点赞数
分类专栏： 笔记 文章标签： java jvm eclipse

多线程例题1
在这里插入图片描述

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThreadDemo15 {
    public static void main(String[] args) {
        int[] arrs=new int[1000000];

        Random random=new Random();
        for (int i = 0; i <arrs.length ; i++) {
            arrs[i]=(random.nextInt(100)+i);
        }

        FutureTask<Integer>task1=new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                 int temp=0;
                for (int i = 0; i <arrs.length ; i=i+2) {
                    temp +=arrs[i];
                }
                System.out.println("线程1："+temp);
                return temp;
            }
        });
        Thread t1=new Thread(task1);
        t1.start();/art

        FutureTask<Integer> task2=new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
               int temp=0;
                for (int i = 0; i <arrs.length ; i++) {
                    temp+=arrs[i];
                }
                return temp;
            }
        });
Thread t2=new Thread(task2);
t2.start();

    }
}


import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo15 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int[] arrs=new int[1000000];

        Random random=new Random();
        for (int i = 0; i <arrs.length ; i++) {
            arrs[i]=(random.nextInt(100)+i);
        }

        FutureTask<Integer>task1=new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                 int temp=0;
                for (int i = 0; i <arrs.length ; i=i+2) {
                    temp +=arrs[i];
                }
                System.out.println("线程1："+temp);
                return temp;
            }
        });
        Thread t1=new Thread(task1);
        t1.start();/art

        FutureTask<Integer> task2=new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
               int temp=0;
                for (int i = 0; i <arrs.length ; i++) {
                    temp+=arrs[i];
                }
                System.out.println("线程2："+temp);
                return temp;
            }
        });
Thread t2=new Thread(task2);
t2.start();
int sum=task1.get()+task2.get();
        System.out.println("最终结果"+sum);

//t1.join();
//t2.join();


    }
}

在这里插入图片描述在这里插入代码片

int[] arrs=new int[10000000];

int[] arrs=new int[2];

在这里插入图片描述57+152=208

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo15 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long stime=System.currentTimeMillis();
        //int[] arrs=new int[10000000];
        int[] arrs=new int[2];
        Random random=new Random();
        for (int i = 0; i <arrs.length ; i++) {
            int temp=random.nextInt(100)+1;
            arrs[i]=temp;
            //arrs[i]=(random.nextInt(100)+i);
            System.out.println(temp);
        }

        FutureTask<Integer>task1=new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                 int temp=0;
                for (int i = 0; i <arrs.length ; i=i+2) {
                    temp +=arrs[i];
                }
                System.out.println("线程1："+temp);
                return temp;
            }
        });
        Thread t1=new Thread(task1);
        t1.start();/art

        FutureTask<Integer> task2=new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
               int temp=0;
                for (int i = 0; i <arrs.length ; i++) {
                    temp+=arrs[i];
                }
                System.out.println("线程2："+temp);
                return temp;
            }
        });
Thread t2=new Thread(task2);
t2.start();
int sum=task1.get()+task2.get();
        System.out.println("最终结果"+sum);

        long etime=System.currentTimeMillis();
        System.out.println("最终执行时间"+(etime-stime));

//t1.join();

在这里插入图片描述17 18
有点没理解 题目再看一下
偶数下标元素的和 奇数下标元素的和 是不是不太对？

复习
在这里插入图片描述在这里插入图片描述![在这里插入图片描述](https://img-blog.csdnimg.cn/71bdd72587994dbc89e405aa4121bc4b.png

上题回顾 多线程
代码含义与我所表达意思不符 for循环内 改变相应条件进行

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo15 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long stime=System.currentTimeMillis();
        //int[] arrs=new int[10000000];

int[] arrs=new int[2];
        Random random=new Random();
        for (int i = 0; i <arrs.length ; i++) {
            int temp=random.nextInt(100)+1;
            arrs[i]=temp;
            //arrs[i]=(random.nextInt(100)+i);
            System.out.println(temp);
        }

        FutureTask<Integer>task1=new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                 int temp=0;
                for (int i = 1; i <arrs.length ; i=i+2) {
                    temp +=arrs[i];
                }
                System.out.println("线程1："+temp);
                return temp;
            }
        });
        Thread t1=new Thread(task1);
        t1.start();/art

        FutureTask<Integer> task2=new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
               int temp=0;
                for (int i = 0; i <arrs.length ; i=i+2) {
                    temp+=arrs[i];
                }
                System.out.println("线程2："+temp);
                return temp;
            }
        });
Thread t2=new Thread(task2);
t2.start();
int sum=task1.get()+task2.get();
        System.out.println("最终结果"+sum);

        long etime=System.currentTimeMillis();
        System.out.println("最终执行时间"+(etime-stime));

//t1.join();
//t2.join();


    }
}


int[] arrs=new int[4];

在这里插入图片描述

public class ThreadSleep {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            try{
                Thread.sleep(60*60*1000);
            }catch (InterruptedException e){
            System.out.println("我接收到了中止执行的通知");}
        });thread.start();
        
        Thread.sleep(1000);
        System.out.println("终止子线程 thread");
    thread.interrupt();
    }

}

##ThreadSleep
在这里插入图片描述### 3

import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;

public class ThreadTimeUtil {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始执行了"+ LocalDateTime.now());
        TimeUnit.DAYS.sleep(1);
        Thread.sleep(24*60*60*1000);
    }

在这里插入图片描述在这里插入代码片

import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;

public class ThreadTimeUtil {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始执行了"+ LocalDateTime.now());
        TimeUnit.SECONDS.sleep(1);
        Thread.sleep(24*60*60*1000);
        System.out.println("主线程又开始执行了"+LocalDateTime.now());
    }
}

定义为秒级 加速sleep

TimeUnit.SECONDS.sleep(3);
        //Thread.sleep(24*60*60*1000);

在这里插入图片描述

总结

在这里插入图片描述在这里插入图片描述

线程状态

*### 三级标题

四级标题
五级标题
六级标题*
public class ThreadState {
    public static void main(String[] args) {
        printState();
    }
    private static void printState(){
        for (Thread.State item:Thread.State.values()) {
            System.out.println(item);
        }
    }
}

在这里插入图片描述
在这里插入图片描述在这里插入图片描述*##*重点记录

import java.util.concurrent.TimeUnit;

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {

        // printState();
        Thread t1=new Thread(()->{
            System.out.println("当前线程状态2："+Thread.currentThread().getState());
            try{
                TimeUnit.SECONDS.sleep(3);
            }catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        });
        System.out.println("当前线程的状态："+t1);
        t1.start();


        Thread.sleep(1000);
        System.out.println("当前线程的状态3"+t1.getState());
    t1.join();
        System.out.println("当前线程的状态4:"+t1.getState());
    }
    private static void printState(){
        for (Thread.State item:Thread.State.values()) {
            System.out.println(item);
        }
    }
}

在这里插入图片描述5为优先级
main为父类线程

       System.out.println("当前线程的状态："+t1.getState());

在这里插入图片描述## 线程安全


public class ThreadDemo16 {
    static class Counter{
    private int number = 0;
    private int MAX_COUNT = 0;

    public Counter(int MAX_COUNT) {
        this.MAX_COUNT = MAX_COUNT;
    }


    public void iner() {
        for (int i = 0; i < MAX_COUNT; i++) {
            number++;
        }
    }

    public void decr() {
        for (int i = 0; i < MAX_COUNT; i++) {
            number--;
        }

    }

    public int getNumber() {
        return number;
    }


    public static void main(String[] args) {
Counter counter=new Counter(100000) ;
counter.iner();
counter.decr();
        System.out.println("最终结果:"+counter.getNumber());

}}}

在这里插入图片描述单线程

public static void main(String[] args) throws InterruptedException {
Counter counter=new Counter(100000) ;
Thread t1=new Thread(()->{
   counter.iner();
});
Thread t2=new Thread(()->{
   counter.decr();
});
//启动多线程
t1.start();
t2.start();
t1.join();
t2.join();
//counter.iner();
//counter.decr();
        System.out.println("最终结果:"+counter.getNumber());

}

在这里插入图片描述在这里插入图片描述在这里插入图片描述两次结果不一致
多线陈处理操作
多线程、
在这里插入图片描述在这里插入代码片

Counter counter=new Counter(100000) ;
Thread t1=new Thread(()->{
   counter.iner();
});
t1.start();
t1.join();
Thread t2=new Thread(()->{
   counter.decr();
});
//启动多线程
//t1.start();
t2.start();
//t1.join();
t2.join();
//counter.iner();
//counter.decr();
        System.out.println("最终结果:"+counter.getNumber());

}

抢占式执行所带来的线程安全问题

、在这里插入图片描述狼多肉少
多个线程修改同一个变量

   static class Counter{
    private int number = 0;
    private int MAX_COUNT = 0;

    public Counter(int MAX_COUNT) {
        this.MAX_COUNT = MAX_COUNT;
    }


    public int iner() {
        int temp=0;
        for (int i = 0; i < MAX_COUNT; i++) {
            temp++;
        }return temp;
    }

    public int decr() {
        int temp=0;
        for (int i = 0; i < MAX_COUNT; i++) {
            temp--;
        }return temp;

    }

    public int getNumber() {
        return number;
    }
static int num1=0;
    static int num2=0;

    public static void main(String[] args) throws InterruptedException {
Counter counter=new Counter(100000) ;
Thread t1=new Thread(()->{
   num1=counter.iner();
});
//t1.start();
//t1.join();
Thread t2=new Thread(()->{
   num2=counter.decr();
});
//启动多线程
//t1.start();
t1.start();
t2.start();
//t1.join();
t1.join();
t2.join();
//counter.iner();
//counter.decr();
        System.out.println("最终结果:"+(num1+num2));

}}

在这里插入图片描述在这里插入图片描述在这里插入图片描述原子性 一组操作封装成一个单元

在这里插入图片描述原子性安全性解释
在这里插入图片描述然后他不知道
把1又给赋景区了
最后结果又变为1了 本来应该是0

在这里插入图片描述上图右为原子性操作解释
上上图为内存解释

在这里插入图片描述内存可见性问题 多线程 导致结果出错
在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

czhc1140075663
关注
专栏目录
【多线程】线程的状态
程序猿教你打篮球的博客
04-21 6117
本期主要讲解： 1.等待一个线程join 2.休眠当前线程 3.线程的状态 3.1认识线程的六种状态 3.2线程的状态转换 4.多线程的优势
java 多线程全局变量_Java多线程操作局部变量与全局变量
weixin_34637138的博客
02-12 2471
在这篇文章里，我们首先阐述什么是同步，不同步有什么问题，然后讨论可以采取哪些措施控制同步，接下来我们会仿照回顾网络通信时那样，构建一个服务器端的“线程池”，JDK为我们提供了一个很大的concurrent工具包，最后我们会对里面的内容进行探索。为什么要线程同步？说到线程同步，大部分情况下， 我们是在针对“单对象多线程”的情况进行讨论，一般会将其分成两部分，一部分是关于“共享变量”，一部分关于“执行...
C#_.Net 5.0异步编程
weixin_45738196的博客
04-20 759
异步编程 一、关键字 c# 关键字 ：async await(不等于多线程） 二、async，await的基本用法 “异步方法”:用async关键字修饰的方法 1)异步方法的返回值一般是Task，T是真正的返回值类型，Task。 2)即使方法没有返回值，也最好把返回值声明为非泛型的Task。 3)调用泛型方法时，一股在方法前加上await关，这样拿到的返回值就是泛型指定的T类型; 4)异步方法的“传染性”:一个方法中如果有await调用，则这个方法也必须修饰为async using System.IO; u
多线程学习笔记(一)--线程的创建
qq383539535的博客
06-10 249
今天准备开始全面学习一下线程，写一篇学习笔记总结一下。代码是借鉴其他博主的，我根据个人理解总结一遍，用于加深一下印象。线程创建方式参考:https://www.cnblogs.com/yjd_hycf_space/p/7526608.html进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位）线程：同一类线程共享...
多线程（五）
哎呦喂儿~
04-18 311
线程池
多线程(一)：创建线程和线程的常用方法
热门推荐
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
线程每隔100ms休眠一次_Java 多线程基础 interrupt()和线程终止方式
weixin_39945816的博客
01-27 503
作者|凌倾-学无止境来源 |cnblogs.com/lingq/p/13039323.htm一、interrupt() 介绍interrupt() 定义在 Thread 类中，作用是中断本线程。本线程中断自己是被允许的；其它线程调用本线程的 interrupt() 方法时，会通过 checkAccess() 检查权限。这有可能抛出 SecurityException 异常。如果...
多线程回顾聚合
weixin_44824330的博客
11-03 448
多线程聚合 写这篇的目的是回顾多线程，纯属个人总结，不足之处，大家多多指导 引言 在我看来，随着商业化网络的大肆发展，许多许多的商业网站，类似淘宝，京东，这种大规模的进行网上交易，牵扯到的一些问题，类似高并发这种问题。虽然在当代，许多许多的框架为我们封装了一系列的操作，让我们对这种高并发问题的产生得到了有效的处理，但是作为程序员我们必须要了解一些底层性，最基础的概念，多线程反而到成了我们学习...
Java 多线程回顾
kismet
08-10 140
进程和线程 进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快，使得所有程序好像是在同时运行一样。 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程在执行
Linux————[多线程详解]
yiren_liusong的博客
06-10 2313
对于一个虚拟地址： 前10位 对应页目录中的地址 中10位 对应页表的页表项的地址 后12位 刚好2^12次方是4KB，所以就是页内偏移， 找一个物理地址： 通过页表项（页框）对应的起始物理地址+虚拟地址后12位对应的数据，就可以访问整个页框的数据。对于一个虚拟地址： 前10位 对应页目录中的地址 中10位 对应页表的页表项的地址 后12位 刚好2^12次方是4KB，所以就是页内偏移， 找一个物理地址： 通过页表项（页框）对应的起始物理地址+虚拟地址后12位对应的数据，就可以访问整个页框的数据。
Java 多线程学习
沉淀、分享、成长，让自己和他人都能有所收获！
04-01 400
栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。例子：开车 + 打电话吃饭 + 玩手机这些动作都可以抽象为任务，虽然看起来一心二用，但人只有一个大脑，在一个时间片刻只能处理一个任务。
C++多线程编程
09-20
在深入了解C++多线程编程之前，我们需要先对进程和线程的基本概念进行简要回顾。 ##### 进程与线程的历史背景 早期计算机系统设计时，由于硬件资源限制，一个程序独占整个系统的资源进行运行是非常普遍的做法。...
python多线程并发让两个LED同时亮的方法
09-19
在深入探讨之前，让我们先简要回顾一下Python多线程的基础知识以及GPIO（General Purpose Input/Output）接口的相关概念。 ##### 1. Python多线程简介 多线程是一种允许一个程序执行多个任务的技术。在Python中，...
Servlet的生命周期
最新发布
wyk的博客
11-13 831
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 246
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
kequanrrr的博客
11-12 364
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 657
Rest请求处理
JAVA学习接口案例实例
shangan_3的博客
11-08 235
【代码】JAVA学习接口案例实例。
深入理解Java的类加载与卸载机制
Luffy的博客
11-12 857
类加载是指JVM将.class文件中的二进制数据读入内存中，经过一系列验证、解析和初始化，最终在JVM中生成可以被使用的Class对象。JVM会为每个类加载并生成一个唯一的Class对象，这个对象封装了类的所有信息，包括方法、属性等。类加载的三大步骤：1.加载（Loading）：从不同的源（如文件、网络）获取类的二进制字节码，并生成Class对象。2.链接（Linking）：对类的二进制进行校验和解析，确保类文件格式正确。验证（Verification）：检查字节码是否符合JVM的规范。
Java多线程实现线程安全单例模式解析
"本文主要探讨了Java多线程环境下的线程安全单例模式，包括其概念、特点以及两种常见的实现方式：懒汉式和饿汉式。" 在Java编程中，单例模式是一种常用的设计模式，其核心目标是确保一个类在整个应用程序中只有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值