Java进阶（再论线程）——线程的4种创建方式 &amp； 线程的生命周期 &amp； 线程的3大特性 &amp； 集合中的线程安全问题

最新推荐文章于 2024-07-08 14:58:49 发布
最新推荐文章于 2024-07-08 14:58:49 发布
阅读量394 收藏 5
点赞数 3
文章标签： java 安全 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84412104/article/details/139935467
版权

3、实现Callable接口

在这里插入图片描述

package com.tianju.threadLearn;


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

/\*\*
 \* Callable，可以有返回值
 \*/
public class ThreadC implements Callable<Long> {



    @Override
    public Long call() throws Exception {
        long sum = 0;
        for (int i = 0; i < 500000; i++) {
            sum+=i;
        }
        return sum;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Long> threadC = new FutureTask<Long>(new ThreadC());
        Thread thread = new Thread(threadC);
        thread.start();
        Long aLong = threadC.get();
        System.out.println(aLong);
    }
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

4、线程池

池化技术pool【常量池、数据连接池、线程池】

在这里插入图片描述

package com.tianju.threadLearn;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PoolDemo1 {
    public static void main(String[] args) {
        System.out.println("===============缓存线程池================");
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i=0;i<10;i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread());
                }
            });
        }
        System.out.println("===============固定线程池================");
        ExecutorService executorService2 = Executors.newFixedThreadPool(1);
        for (int i=0;i<10;i++) {
            executorService2.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread());
                }
            });
        }
    }
}

二、线程的生命周期

在这里插入图片描述

join()：运行结束再下一个

在这里插入图片描述

package com.tianju.threadLearn;

public class ThreadA1 extends Thread{

    static int c = 0;

    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {

            try {
                System.out.println(this.getName()+": "+i);
                sleep(300);
                c++;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadA1 a = new ThreadA1();
        a.setName("A");

        ThreadA1 b = new ThreadA1();
        b.setName("B");
        a.start();
        a.join(); // A运行结束，B才能开始运行

        b.start();
        b.join(); // 控制执行顺序

        System.out.println(Thread.currentThread().getName());
        System.out.println("c的结果为: "+c);

    }
}

在这里插入图片描述

yield()：暂时让出cpu的使用权

在这里插入图片描述

package com.tianju.threadLearn;

/\*\*
 \* yield，让出cpu的使用权
 \*/
public class ThreadA2 extends Thread{

    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {

            try {
                if (i%2==0){
                    // 让出cpu的使用权，避免一个线程一直占有cpu，防止独占cpu
                    // 重新竞争
                    yield();
                }
                System.out.println(this.getName()+": "+i);
                sleep(300);

            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadA2 a = new ThreadA2();
        a.setName("A");

        ThreadA2 b = new ThreadA2();
        b.setName("B");
        a.start();

        b.start();

        System.out.println(Thread.currentThread().getName());

    }
}

deamon()：守护线程，最后结束

在这里插入图片描述

在这里插入图片描述

package com.tianju.threadLearn;

/\*\*
 \* 守护线程
 \* 用户线程
 \*
 \*/
public class ThreadA3 extends Thread{

    @Override
    public void run(){

        while (true){
            System.out.println("我是守护线程.......");
            try {
                sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

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

        ThreadA3 a = new ThreadA3();
        a.setName("A");
        a.setDaemon(true); // 守护线程，用户线程main结束后，他就结束了
        a.start();

        for (int i =0;i<10;i++){
            System.out.println(Thread.currentThread()+":"+i);
            Thread.sleep(200);
        }

    }
}

在这里插入图片描述

sleep()：如果有锁，不会让出

在这里插入图片描述

package com.tianju.threadLearn;

public class ThreadSleep extends Thread{



    @Override
    public void run(){

        for (int i=0;i<10;i++){
            System.out.println("我是线程A："+this.getName());

            try {
                sleep(200); // 不会让出锁
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }

    public static void main(String[] args) {
        ThreadSleep threadA = new ThreadSleep();
        threadA.setName("线程A");

        threadA.start(); // 我准备好了

        String name = Thread.currentThread().getName();
        System.out.println(name);

    }
}

三、线程的三大特性

在这里插入图片描述

原子性：AtomicInteger

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.tianju.tx;

import java.util.concurrent.atomic.AtomicInteger;

/\*\*
 \* 解决原子性：AtomicInteger
 \*/
public class AtomicDemo1 {
    static AtomicInteger x= new AtomicInteger();
    static class A extends Thread{
        @Override
        public void run() {

            for (int i = 0; i < 20; i++) {
                x.incrementAndGet();
                System.out.println(getName()+ "--x:"+x);
                try {
                    sleep(200);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
        }
    }

    public static void main(String[] args) {
        new A().start();
        new A().start();
        new A().start();
    }
}

在这里插入图片描述

CAS

CAS(Compare And Swap)

  • 从主存拷贝到工作内存(线程)
  • 修改，和主存比较，如果如果和取时结果一致，刷新到主存中。

ABA问题:

如果红色线程拿到了主存中的3，进行加1,；

蓝色线程也拿到了主存中的3，进行了加1，然后又减1；

红色线程一直问主存里面是不是3，然后发现还是3，就把4写到主存里面；

但是此时的3已经被蓝色线程动过了；

解决方案是，加一个版本号，每次被操作，就让版本号加1

在这里插入图片描述

可见性：加volatile关键字

在这里插入图片描述

package com.tianju.view;

/\*\*
 \* 线程之间不可见
 \* volatile 用于解决可见性
 \*/
public class VisibleDemo2 {
    volatile static boolean f = true; // 处理可见性，解决不了原子性
    static class A extends Thread{

        @Override
        public void run() {
            while (f){

            }
            System.out.println("A的f为："+f);
        }
    }
    static class B extends Thread{
        @Override
        public void run() {
            f=false;
            System.out.println("B设置f为："+f);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new A().start();
        Thread.sleep(300);
        new B().start();
    }
}

在这里插入图片描述

有序性：引用有了，对象还没

在这里插入图片描述

假设： 编译器修改顺序 1 , 3, 2

线程A执行到对象初始化阶段，还没有初始化；

线程B先获得的对象的引用，然后调用对象，

但是对象还没有初始化，因此会报错，对象初始化错误

在这里插入图片描述

四、集合中的线程安全问题

1、List集合的问题

在这里插入图片描述

在这里插入图片描述

package com.tianju.collection;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class ListDemo {
    static List<Integer> list = new ArrayList<>();

    // 有序性+原子性保证
    volatile static AtomicInteger index =new AtomicInteger(0);
    static class A extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                list.add(index.incrementAndGet());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        A a1 = new A();
        A a2 = new A();
        A a3 = new A();
        a1.start();
        Thread.sleep(500);
        a2.start();
        a3.start();
        System.out.println(list);
    }
}
用vector解决

在这里插入图片描述

package com.tianju.collection;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.atomic.AtomicInteger;

public class VectorDemo {
    static Vector<Integer> list = new Vector<>();

    // 有序性+原子性保证
    volatile static AtomicInteger index =new AtomicInteger(0);
    static class A extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                list.add(index.incrementAndGet());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        A a1 = new A();
        A a2 = new A();
        A a3 = new A();
        a1.start();
        a1.join(); // A运行结束，B才能开始运行
        a2.start();
        a2.join();
        a3.start();
        a3.join();
        System.out.println(list);
    }
}
用Collections.synchronizedList
package com.tianju.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.atomic.AtomicInteger;

public class CollectionDemo {
    static List<Integer> ls = new ArrayList<>();
    static List<Integer> list = Collections.synchronizedList(ls);

    // 有序性+原子性保证
    volatile static AtomicInteger index =new AtomicInteger(0);
    static class A extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                list.add(index.incrementAndGet());


![img](https://img-blog.csdnimg.cn/img_convert/4433b0211098bac57e68ef657e71e9c0.png)
![img](https://img-blog.csdnimg.cn/img_convert/4f5b59fefb74ac64b6f2d27ccdc14ff0.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

 ArrayList<>();
    static List<Integer> list = Collections.synchronizedList(ls);

    // 有序性+原子性保证
    volatile static AtomicInteger index =new AtomicInteger(0);
    static class A extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                list.add(index.incrementAndGet());


[外链图片转存中...(img-15TIJYzD-1719227178953)]
[外链图片转存中...(img-sbE0zB7g-1719227178954)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84412104
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java虚拟机学习和总结（1&amp;2）
02-13
4. **分代收集**：根据对象的生命周期不同，将堆内存分为新生代和老年代，采用不同的回收策略，如Minor GC和Full GC。 其次，运行时数据区域是JVM执行Java程序的关键组成部分，主要包括： 1. **程序计数器**：每个...
Servlet(十)&amp;amp;amp;amp;amp;request(十一).zip
06-18
1. **Servlet生命周期**：Servlet在服务器启动时被加载，通过`init()`方法初始化，然后在每次客户端请求时调用`service()`方法，最后在服务器关闭或Servlet卸载时执行`destroy()`方法。 2. **Servlet配置**：...
线程的三种创建方式 &amp； 6种状态
LC的博客
01-04 167
操作系统线程和Java线程的区别 他们之间的状态是不同的，看下面的介绍 Java提供两个线程：守护线程和用户线程 守护线程又称为”服务进程、后台线程“。是指在程序在运行时在后台提供一种通用的服务的线程，对应程序来说时非必要的 用户线程，JVM内部提供的，比如main主线程和GC线程（垃圾回收机制） #线程的三种实现方式： 继承Thread类，重写run方法 实现Runnable接口，重写run方法 实现Cllable接口，重写call方法 方法三的功能更加强大： call方法有返回值，可抛异常 .
Java学习笔记（四）：创建多线程的四种方式 & 同步机制
qq_40177015的博客
03-06 210
文章目录基本概念程序（program）进程（process）线程（thread）多线程（multi-thread）优点应用场合生成线程Java同步机制来解决线程安全的问题死锁同步机制同步代码块同步方法Lock（JDK5.0增加）synchronized和Lock的异同点线程通信涉及到的方法：wait() &amp; notify() &amp; notifyAll()sleep() &amp; wait()创建线程的其他方式实现Callable接口（JDK5增加）线程池 基本概念 程序（program） 一
多线程编程（中）：线程的生命周期&调度
Lucky_mzc的博客
04-27 625
本章概述 通过上一章的学习，我们已经对线程及其创建有了深入的了解；本章将继续学习线程的相关知识，深入学习线程的生命周期，多线程协调对CPU的使用。 多线程编程（上）：进程.线程概念&amp;线程创建 一. 线程的生命周期 创建线程对象时，线程的生命周期就已经开始了，直到线程对象被撤销为止。在这整个生命周期中，线程并不是一个创建就进入可运行状态，线程启动之后，也不是一直处于可运行状态。在这个生命周期中，线程含有多种状态，这些状态之间可以相互转化。 Java的线程的生...
线程笔记——创建线程的三种方式
做一个善良的码农
07-23 229
1、继承Thread类，重写run()方法 public class ThreadTest extends Thread{ // 重写run方法，run方法的方法体就是线程执行体 @Override public void run(){ System.out.println(&amp;quot;I am run() by ' extends Thread ',my nam...
线程的创建方式及生命周期
以码为梦
03-10 337
线程创建的两种方式 /** * Description: &amp;lt;br&amp;gt; * * @author: name：yuxin &amp;lt;br&amp;gt;email: yuruixin@ixincheng.com &amp;lt;br&amp;gt; * Create Time: 2018/3/10 0010-下午 5:30&amp;lt;br&amp;gt; */ public class MyThread1 ex...
Java 创建多线程的四种方式 & 线程安全问题
insp1re的博客
03-20 185
Java多线程一、基本概念二、线程的创建与使用方式一：继承Thread类方式二：实现Runnable接口继承Thread类 &amp; 实现Runnable方法 区别三、线程的生命周期四、线程安全问题方式一：同步代码块方式二：同步方法单例设计模式的线程安全问题 一、基本概念 程序：一段静态的代码。完成特定任务，用某种语言编写的一组指令的集合。 进程：正在运行的一个程序。是动态的的过程，存在生命周期。 线程：一个程序内部的一条执行路径，作为调度和执行的单位。每个线程运行拥有独立的运行栈和程序计数器(PC)。
Java初学——多线程基本知识总结
qq_42044213的博客
03-05 232
一、基本概念 1. 程序 &amp; 进程 &amp; 线程        程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。        进程(process)是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程。它有自身的产生、存在和消亡的过程——生命...
android 快速创建一个新的线程 &amp;amp; android线程的正确使用
热门推荐
aZzdf的博客
03-10 2万+
下面的一段转载自：http://blog.sina.com.cn/s/blog_71dbc27f01017mnj.html下面是快速创建一个新线程的方法：第一种：直接创建子线程并启动      new Thread() {@Overridepublic void run() {     //这里写入子线程需要做的工作        }   }.start();   第二种：先创建子线程，然后启动 ...
java——》进程 && 线程
小仙~
03-05 137
版权声明：本文为博主原创文章，无需授权即可转载，甚至无需保留以上版权声明，转载时请务必注明作者。 https://blog.csdn.net/weixin_43453386/article/details/88184422 java——》进程 &amp;amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp;amp; 线程 一、车间 &amp;amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;a
Rust Series，语法基础、数据结构、并发编程、工程实践，常见的代码示例 &amp; 数据结构与算法.zip
06-16
Rust的并发特性主要体现在其所有权和生命周期系统。线程（`thread`）和通道（`channel`）是实现并发的主要工具。通过`async/await`语法，Rust支持异步编程，允许编写非阻塞I/O，提高了程序性能。 4. **工程实践**...
A fast entity component system (ECS) for C &amp; C++.zip
12-27
为了防止这些问题，可以使用智能指针（如std::unique_ptr或std::shared_ptr）来自动管理组件的生命周期。此外，为了达到高性能，ECS通常会使用数据导向设计，将具有相同组件的实体存储在一起，便于系统进行批处理...
汪文君高并发编程实战视频资源全集
08-08
│ 高并发编程第一阶段16讲、采用优雅的方式结束线程生命周期.mp4 │ 高并发编程第一阶段17讲、Thread API综合实战，编写ThreadService实现暴力结束线程的综合实战.mp4 │ 高并发编程第一阶段18讲、数据同步的...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 535
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 720
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
如何在淘客返利系统中实现高效的搜索与推荐算法
微赚淘客开发者博客
07-08 431
本文介绍了如何在淘客返利系统中实现高效的搜索与推荐算法，涵盖了倒排索引技术、搜索结果排序优化以及协同过滤、基于内容的推荐算法的实现方法和示例。通过合理选择和优化算法，可以显著提升系统的搜索效率和推荐精度，从而增强用户体验和平台的竞争力。微赚淘客系统3.0小编出品，必属精品，转载请注明出处！
springboot中抽离日志
最新发布
qq_24223159的博客
07-08 187
【代码】springboot中抽离日志。
Java多线程-对比创建多线程的两种方式
01-25
"Java编程中，创建多线程有两种主要方式：继承Thread类和实现Runnable接口。这两种方式在实现多线程上有各自的特点和适用场景。下面将详细对比这两种方式，并通过实例进行说明。\n\n一、对比两种方式\n\n（1）对比\n...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值