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

于 2024-09-22 11:35:09 发布
阅读量728 收藏 20
点赞数 19
文章标签： java 安全 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87298459/article/details/142434063
版权 
    this.name = name;
}

@Override
public void run() {
    for(int i =0;i<10;i++){
        System.out.println("当前线程："+this.name);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

public static void main(String[] args) {
    new Thread(new ThreadB("B")).start();
}

}


### 3、实现Callable接口


![在这里插入图片描述](https://img-blog.csdnimg.cn/46d56dcb7f79431ca173a25f3cb81208.png)

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 {

@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);
}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/ffa6ba3e47a1450b83dd73b4f79ed2c4.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/b14ee1f4f71349d29e76ae63b569afdb.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/e6fcf67aac8443d5887fde2ef87d1fe5.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/a2459384ac00408a88f2e8654640f690.png)


### 4、线程池


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/ad11ab5cb6514f85ad993c77493cc17d.png)

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());
}
});
}
}
}


## 二、线程的生命周期


![在这里插入图片描述](https://img-blog.csdnimg.cn/d3527b26da9c49e28762a7caa379121f.png)


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/2f94331774534cae8d7303ced38fd210.png)

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);

}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/410cbc6e4abc4aa89c3572f88d0fb0b9.png)


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/ea6ec42649a640ecbb07c42c5a0aa8ec.png)

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()：守护线程，最后结束


![在这里插入图片描述](https://img-blog.csdnimg.cn/9257035e5fa449cc927c9fb7f5426e2a.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/ff9f55464812475f8be3bc467a4018b1.png)

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);
    }

}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/7cce831beccb4dafbdcab38ecab6031a.png)


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/2ec4289cdb014fefaaf28dd65058b191.png)

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);

}

}


## 三、线程的三大特性


![在这里插入图片描述](https://img-blog.csdnimg.cn/00e8f4fecd004ae7bdb95177f242bf84.png)


### 原子性：AtomicInteger


![在这里插入图片描述](https://img-blog.csdnimg.cn/1504907fe71f46d98e2f77b3a758a9c3.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/6c3e464a6f1a45e6a0f9a21b56183886.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/62a097c2632a4c2895ab3c778ef8cbd1.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/244c47558a1f48ce9711fc6619f800ae.png)

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();
}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/0631ad9ef9724f4f91a837fc1806f1d9.png)


#### CAS



> 
> CAS(Compare And Swap)
> 
> 
> 


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



> 
> ABA问题:
> 
> 
> 如果红色线程拿到了主存中的3，进行加1,；
> 
> 
> 蓝色线程也拿到了主存中的3，进行了加1，然后又减1；
> 
> 
> 红色线程一直问主存里面是不是3，然后发现还是3，就把4写到主存里面；
> 
> 
> 但是此时的3已经被蓝色线程动过了；
> 
> 
> 解决方案是，加一个版本号，每次被操作，就让版本号加1
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/8a296f85af6a4d4a8390fab350aba28b.png)


### 可见性：加volatile关键字


![在这里插入图片描述](https://img-blog.csdnimg.cn/e9a9fc4a755f4681bca9e9af165bbc80.png)

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();
}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/ccfba2bebd5d461190561a4cd8747f4e.png)


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/742a4e1ea92544f1bf5f101db3d440d4.png)



> 
> 假设： 编译器修改顺序 1 , 3, 2
> 
> 
> 线程A执行到对象初始化阶段，还没有初始化；
> 
> 
> 线程B先获得的对象的引用，然后调用对象，
> 
> 
> 但是对象还没有初始化，因此会报错，对象初始化错误
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/b4b7c4571ec54f538842e8074ea5eb02.png)


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


### 1、List集合的问题


![在这里插入图片描述](https://img-blog.csdnimg.cn/c138462c042f41d284c840f687c87ad1.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/514f303f0f29461a882406cfa4f064d2.png)

package com.tianju.collection;

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

public class ListDemo {
static List 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解决


![在这里插入图片描述](https://img-blog.csdnimg.cn/a6c1dfe726544d55a01cb34548069300.png)

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 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 ls = new ArrayList<>();
static List 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());
        }
    }
}

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);
}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/2cc702151baa430aabac9e2d14825553.png)


### 2、表格总结




| 序号 | 线程不安全 | 线程安全 |
| --- | --- | --- |
| 1 | ArrayList | Vector/ Collections.synchronizedList(list) |
| 2 | HashMap | ConcurentHashMap/HashTable |
| 3 | HashSet | Collections.synchronizedSet() |


Hashset的底层是HashMap


![在这里插入图片描述](https://img-blog.csdnimg.cn/d9c5ebfd3c80427bb1588aa473a17a4a.png)


### 3、关于hash算法


比如一开始有蓝色点，经过hash算法之后，得到结果3，然后放到相应的位置；


然后又来了一个红色的点，经过hash算法之后，也是3，此时就顺着蓝色的位置去找；


之前是采用头插法，就是新来的放到蓝色的之前，在1.8之后改成尾插法，放到蓝色的后面；


如果又有新来的，就继续往后面加，此时出现了不利的情况，就是越来越多成了一个很长的链表；


所以就采用了树的结果，这样提高的查找的效率；在1.8中采用的红黑树；


![在这里插入图片描述](https://img-blog.csdnimg.cn/ece1f0457740487b9fbedc79fcf468a8.png)
2401_87298459
关注
怎样才能从Java初级程序员成长为一名合格的架构师？
xiaoxijing的博客
11-11 1787
怎样学习才能从一名Java初级程序员成长为一名合格的架构师？或者说一名合格的架构师应该有怎样的技术知识体系？这不仅仅是一个刚刚踏入职场的初级程序员也是工作三五年之后开始迷茫的老程序员经常会问到的问题。下面，我来详细回答这些问题。希望这篇文章会是你看到过的最全面最权威的回答。 一、编程基础 不管是C还是C++，不管是Java还是PHP，想成为一名合格的程序员，基本的数据结构和算法基础还是要有的。下...
Java语言基础六之(IO流、多线程)
bier_zm的博客
08-15 1706
1、IO流 io ==> input &amp; output分类 按读写数据的基本单位分类 -- 字节流 和 字符流。 其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的文件。 其中字符流主要指以字符(2个字节)为单位进行数据读写的流，只能读写文本文件。 按照读写数据的方向不同分类 -- 输入流 和 输出流（站在程序的角度） 其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文件。 其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。
Java进阶篇
Java精灵
05-29 3960
Java面试中最常被问知识点（进阶篇）Java面试中最常被问的知识1、深复制和浅赋值的区别深复制：将指向内容复制到给当前对象新分配的缓冲区中的一种复制方式。浅复制：指当对象的字段值被复制时，字段引用的对象不会被复制。2、为什么Java中有些接口没有任何方法？3、什么是反射机制？反射的功能4、Java有几种创建对象的方法？5、简述final、finally、finalize的区别(1) finala、使用final声明属性时，表示属性不可再改变 ，且必须被初始化。b、使用final声明方法时，表示方法不可被重
Java技能提升指南
热门推荐
大厂全栈码农
08-27 1万+
Java学习的过程是一个持续积累和实践的过程。通过夯实基础、深入理解进阶技能、在项目实战中锻炼、熟练使用工具与框架，以及保持对行业动态的关注，您将能够不断提升自己的Java技能，成为一名优秀的Java开发者。
java进阶
edwer93的博客
12-03 722
https://blog.csdn.net/qq_29411737/article/details/80835658?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166515221516782428638820%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=166515221516782428638820&biz_id=0&utm_mediu
Java进阶
Sermisry的博客
11-18 273
文章目录正则表达式几种遍历方法日期类随机数RandomWrapperClass 正则表达式 本人觉得这个可以不必要记的emm，理解至上 package cn.edu.tyut.demo; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.junit.Test; public class RegexNumber { @Test public void fun1() { //1、写出一个正
Java虚拟机学习和总结（1&amp;2）
02-13
4. **分代收集**：根据对象的生命周期不同，将堆内存分为新生代和老年代，采用不同的回收策略，如Minor GC和Full GC。 其次，运行时数据区域是JVM执行Java程序的关键组成部分，主要包括： 1. **程序计数器**：每个...
2022最新版Java多线程&并发面试题总结（108道题含答案解析）
qq3164069700的博客
02-21 1788
前言 最近面试的小伙伴很多，对此我整理了一份Java面试题手册：基础知识、JavaOOP、Java集合/泛型面试题、Java异常面试题、Java中的IO与NIO面试题、Java反射、Java序列化、Java注解、多线程&amp;并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、SpringBoot、SpringCloud、RabbitMQ、Dubbo、MyBatis、ZooKeeper、数据结构、算法、Elasticsearch、Kafka、微服务、Linux等等。可
笔记-Java多线程
weixin_43919304的博客
11-30 221
进程&amp;线程 进程（Process）就是一个运行的程序过程，是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配(有独立的地址空间、进程ID等)和调度的基本单位，是操作系统结构的基础。 进程资源有：包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分...
C++ 线程安全下Lock 类的两种使用方式
I-am-Unique
12-19 1万+
“不定义，做一个保持好奇心的普通人”   꿈을 이루게 될 거예요. 2018.12.19 快三年了：   Mutex 又称互斥量，C++ 11中与 Mutex 相关的类（包括锁类型）和函数都声明在 &amp;lt;mutex&amp;gt; 头文件中，所以如果你需要使用 std::mutex，就必须包含 &amp;lt;mutex&amp;gt; 头文件。 &amp;lt;mutex&amp;gt; 头文件介绍 Mutex 系...
java高级进阶知识
02-27
深入理解java虚拟机(第二版)----jvm高级特性与最佳实践，该书系统详细的介绍了java虚拟机的高级进阶知识
Java编程进阶
geek_like的博客
03-19 304
一、类和对象 1、面向对象的概念 现实世界就是“面向对象的”。任何存在的事物都可以看作“对象”。 面向对象就是采用“现实模拟”的方法设计和开发程序。面向对象技术利用“面向对象的思想”去描述“面向对象的世界”，实现了虚拟世界和现实世界的一致性，符合人们的思维习惯使设计开发人员之间更加流畅，同时有代码重用性高、可靠性等优点，大大提高了软件尤其是大型软件的设计和开发效率。 2、使用面向对象进行程序设计 ...
Java进阶（一）
最新发布
qq_49474843的博客
09-06 1630
接上篇Java基础，这里详细介绍了Java进阶的部分内容，包含字符串相关类，异常，集合，泛型等
Java线程生命周期详解：创建、运行到停止
Java线程的生命周期是其生命周期中的四个关键阶段：启动、运行、阻塞/挂起和终止。本文将详细介绍这些状态以及相关的Thread类方法。 1. **启动（等待）**： 当一个线程被创建后，它并不立即开始执行run()方法中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值