线程状态 线程同步

已于 2023-03-08 15:02:13 修改
阅读量54 收藏
点赞数
分类专栏： Javase + Java面向对象 + 线程 文章标签： java jvm 开发语言
于 2023-02-28 19:40:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lzzzzzzk/article/details/129267726
版权

2023.02.28 星期二

1. 线程状态

在这里插入图片描述

1.1 初始状态

一个刚被创建好的线程对象，就是初始状态的对象。

Thread t = new Thread(new Runnable02());

当前新创建的t线程对象就是初始状态。

1.2 可运行状态

一个线程想要运行必须先抢到CPU。启动与运行是不同的概念。

当一个线程对象调用了start()方法启动了，但还没有抢到CPU时，都是一个可运行状态。

可运行状态的线程对象只做一件事：抢CPU。

1.3 运行状态

一个抢到CPU正在执行的线程对象。称为运行状态。

当一个运行状态的线程对象，CPU时间到期要转换为可运行状态。

1.4 终止状态

一个执行完成run()方法的线程对象，就是终止状态。

2. 线程中的常用属性和方法
2.1 name属性

用来表示一个线程对象的名称。可以在创建线程对象时指定。也可以通过方法指定。

public class NameTest {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnbale02(),"线程1");

        System.out.println(t.getName());
    }
}
2.2 currentThread()

Thread类的静态方法。动态获取当前执行的线程对象。
public static native Thread currentThread()

public class Runnbale02 implements Runnable{
    @Override
    public void run() {
        for(int i = 1;i<=10;i++) {
            String name = Thread.currentThread().getName();
            System.out.println(name+"-"+ i+":000");
        }
    }
}
2.3 sleep()

休眠方法。
哪一个线程运行过程中，遇到sleep方法。哪一个线程自己休眠。
public static native void sleep(long millis) throws InterruptedException

public class Runnbale02 implements Runnable{
    @Override
    public void run() {
        for(int i = 1;i<=100;i++) {
            String name = Thread.currentThread().getName();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name+"-"+ i+":000");
        }
    }
}
3. 阻塞状态

线程对象运行过程中，出现以下情况：
1 等待IO。做标准输入时，用户需要从控制台输入数据时。
2 sleep方法。当前线程休眠。
当线程遇到以上二种情况时，会进入阻塞状态。并会释放CPU。
在这里插入图片描述

4. 本地线程对象ThreadLocal类
4.1 本地线程对象是什么？

本地线程对象其实是一个容器。而且是一个只能保存一个数据的容器对象。

这个容器在每一个不同的线程中，都有一份自己的实例。

每一个线程对象都使用自己的ThreadLocal类的实例。

当出现多个线程时，每一个线程中都有一个自己使用的ThreadLocal对象。

4.2 常用方法
public static void main(String[] args) {
    ThreadLocal<String> local = new ThreadLocal<>();

    local.set("peter");

    String s = local.get();

    System.out.println(s);
}
5. 案例：取款与存款案例
1 编写二个任务

一个存款
一个取款

2 专家原则

专家原则：事情哪个对象最清楚，哪个对象负责。

3 编写账号的类
public class Acount {
    private Double money;
    public Acount(Double money) {
        this.money = money;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
}
4. 编写DAO
public class AcountDAO {
    public void update(Acount acount,Double money){
        acount.setMoney(money);
    }
}
5. 编写Service
public class AcountService {
    private AcountDAO acountDAO = new AcountDAO();

    public void deposit(Acount acount,Double money){
        double temp = acount.getMoney();
        temp = temp + money;
        acountDAO.update(acount,temp);
    }
    public void draw(Acount acount,Double money) throws Exception {
        double temp = acount.getMoney();
        if (temp > money) {
            temp = temp - money;
            acountDAO.update(acount, temp);
        }else {
            throw new Exception("账户余额不足！！！");
        }
    }
}
6. 编写任务类

任务类一定是与Service层对接。

public class DepositRunnable implements Runnable{
    private AcountService service = new AcountService();
    private Acount acount;
    private Double money;
    public DepositRunnable(Acount acount, Double money) {
        this.acount = acount;
        this.money = money;
    }
    @Override
    public void run() {
        service.deposit(acount,money);
        System.out.println("存款成功！"+acount.getMoney());
    }
}



public class DrawRunnable implements Runnable{
    private AcountService service = new AcountService();
    private Acount acount;
    private Double money;
    public DrawRunnable(Acount acount, Double money) {
        this.acount = acount;
        this.money = money;
    }
    @Override
    public void run() {
        try {
            service.draw(acount,money);
            System.out.println("取款成功！"+acount.getMoney());
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(e.getMessage()+"取款失败！"+acount.getMoney());

        }
    }
}
7. 编写测试类
public static void main(String[] args) {
    Acount acount = new Acount(10000.0);

    DepositRunnable depositRunnable01 = new DepositRunnable(acount,10000.0);
    DepositRunnable depositRunnable02 = new DepositRunnable(acount,2000.0);

    DrawRunnable drawRunnable01 = new DrawRunnable(acount,5000.0);

    Thread t1 = new Thread(depositRunnable01,"自己");
    Thread t2 = new Thread(depositRunnable02,"父母");
    Thread t3 = new Thread(drawRunnable01,"女朋友");

    t1.start();
    t2.start();
    t3.start();
 }

会出现数据不一致的情况。
账户的余额会经常变化。不是一个正确的固定的数值。

6. 线程不安全

线程不安全是指多个线程在操作数据时，数据不正确的情况。

线程不安全的几个条件：
1 多个线程 - 多线程
2 同时操作 - 并发
3 同一个数据 - 临界资源
4 破坏了不可分割的操作时 - 原子性
当以上的情况发生时，就有可能造成数据的不一致。这种情况就称线程不安全。

当多线程并发操作临界资源时，破坏了其原子性操作时，就有可能造成数据不一致。

解决方案：线程同步

7. 线程同步

线程同步：多个线程以串行的方式执行。这种方式称为线程同步。
手拉手一起走，是异步。
串行的方式执行：是针对对临界资源的操作部分以串行的方式操作。

7.1 同步锁synchronized

我们使用同步锁，开保证临界资源的原子性操作不被分割。

在执行原子性操作之前，先获取同步锁对象。之后再执行原子性代码。只有原子性代码执行完成之后。我们才会释放同步锁对象。

特殊注意：只有使用同一个同步锁的多个线程，才会以串行的方式执行。

必须要保存，多个线程使用的是同一个锁对象。才能叫多个线程的同步。

一般情况下，临界资源做为锁对象更合适。

7.2 同步锁的使用方式一

synchronized（锁对象）{
原子性操作代码;
}

public class DepositRunnable implements Runnable{
    private AcountService service = new AcountService();
    private Acount acount;
    private Double money;
    public DepositRunnable(Acount acount, Double money) {
        this.acount = acount;
        this.money = money;
    }
    @Override
    public void run() {
        synchronized (acount) {
            System.out.println(Thread.currentThread().getName() + "-存款任务开始！");
            service.deposit(acount, money);
            System.out.println(Thread.currentThread().getName() + "-存款成功！" + acount.getMoney());
            System.out.println(Thread.currentThread().getName() + "-存款任务结束！");
        }
    }
}




public class DrawRunnable implements Runnable {
    private AcountService service = new AcountService();
    private Acount acount;
    private Double money;

    public DrawRunnable(Acount acount, Double money) {
        this.acount = acount;
        this.money = money;
    }

    @Override
    public void run() {
        synchronized (acount) {
            System.out.println(Thread.currentThread().getName() + "-取款开始！");
            try {
                service.draw(acount, money);
                System.out.println(Thread.currentThread().getName() + "-取款成功！" + acount.getMoney());
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println(Thread.currentThread().getName() + "-" + e.getMessage() + "取款失败！" + acount.getMoney());
            }
            System.out.println(Thread.currentThread().getName() + "-取款结束！");
        }
    }
}

Test类：

public class Test {
    public static void main(String[] args) {
        Acount acount = new Acount(10000.0);//临界资源

        DepositRunnable depositRunnable01 = new DepositRunnable(acount,10000.0);
        DepositRunnable depositRunnable02 = new DepositRunnable(acount,2000.0);

        DrawRunnable drawRunnable01 = new DrawRunnable(acount,5000.0);
        DrawRunnable drawRunnable02 = new DrawRunnable(acount,5000.0);

        Thread t1 = new Thread(depositRunnable01,"自己");
        Thread t2 = new Thread(depositRunnable02,"父母");
        Thread t3 = new Thread(drawRunnable01,"女儿");
        Thread t4 = new Thread(drawRunnable02,"老婆");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
     }
}
7.3 同步锁的使用方式二

可以直接在方法上声明。

public synchronized void add();

等价于：

public class A{
public synchronized void add(){
}
}
//=========》
public class A{
public void add(){
	synchronized(this){
			
}
}
}

A a = new A();
a.add();
a.add();

A a1 = new A();
a1.add();

这个调用的add方法与a对象调用的add方法不同步。

对于Vector类来说：多个线程同时操作同一个Vector对象。调用其add方法时，是以同步方式保存对象。称为线程安全。

7.4 同步锁的使用方式三（JDK5）

在JDK1的线程时，锁对象类型是Object。表示任意类型都可以做为锁对象。

实际开发时，一般使用临界资源对象做为锁对象。

到了JDK5，就专门创建了一个锁对象。

java.util.concurrent.locks.Lock接口

public interface Lock {
	void lock();
	void unlock();
}

java.util.concurrent.locks.ReentrantLock 实现类

public class ReentrantLock implements Lock, java.io.Serializable{
}

创建一个锁对象的方式

Lock lock = new ReentrantLock();

修改方式一的线程任务类

public class DepositRunnable implements Runnable {
    private AcountService service = new AcountService();
    private Acount acount;
    private Double money;
    private Lock lock;//锁对象
    public DepositRunnable(Acount acount, Double money, Lock lock) {
        this.acount = acount;
        this.money = money;
        this.lock = lock;
    }
    @Override
    public void run() {
        lock.lock();//加锁
        System.out.println(Thread.currentThread().getName() + "-存款任务开始！");
        service.deposit(acount, money);
        System.out.println(Thread.currentThread().getName() + "-存款成功！" + acount.getMoney());
        System.out.println(Thread.currentThread().getName() + "-存款任务结束！");
        lock.unlock();//解锁
    }
}

public class Test {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();//实例化锁对象
        Acount acount = new Acount(10000.0);//临界资源

        DepositRunnable depositRunnable01 = new DepositRunnable(acount,10000.0,lock);
        DepositRunnable depositRunnable02 = new DepositRunnable(acount,2000.0,lock);

        DrawRunnable drawRunnable01 = new DrawRunnable(acount,5000.0);
        DrawRunnable drawRunnable02 = new DrawRunnable(acount,5000.0);

        Thread t1 = new Thread(depositRunnable01,"自己");
        Thread t2 = new Thread(depositRunnable02,"父母");
        Thread t3 = new Thread(drawRunnable01,"女儿");
        Thread t4 = new Thread(drawRunnable02,"老婆");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
     }
}
Lzzzzzzk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程之线程状态
qq_51993933的博客
06-24 2828
## 线程状态 五大状态 1.创建状态：Thread thread = new Thread(); 线程对象一旦创建就进入了新生状态。 2.就绪状态：当调用start()方法时，进入就绪状态，但不代表立即调度执行（等待cpu调度）。 3.运行状态或同态：进入运行状态，线程才真正执行线程体的代码块。 4. 阻塞状态：当调用sleep,wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞解除后进入就绪状态，等待cpu调度。 5.死亡状态：线程中断或者结束，进入死亡状态，不能再次启动。 停止线程
线程同步
李十八的博客
06-06 219
  在单线程中，每次只做一件事情，但是如果使用多线程，就会发生两个线程抢占资源的问题，比如两个人过独木桥，两个人同时说话，所以要在线程编程中避免这些资源访问的冲突。Java 提供了线程同步的机制来防止资源访问的冲突。 一、线程安全 在实际开发中，使用多线程的情况很多，如网上购票系统，银行排号系统。以火车站售票系统为例，在代码中判断票数是否大于0，如果大于 0 则执行售票功能，但是当多个线程同时访问...
C#的线程同步
IT技术猿猴的博客
04-05 4067
使用线程有几个原因。假设从应用程序中进行网络调用需要一定的时间。我们不希望用户界面停止响应，让用户一直等待直到从服务器返回一个响应。用户可以同时执行其他一些操作，或者甚至取消发送给服务器的请求。这些都可以使用线程来实现。 线程是程序中独立的指令流。使用C编写任何程序时，都有一个入口点:Main()方法。程序从Main(方法的第一条语句开始执行，直到这个方法返回为止。 这种程序结构非常适合于其中有一个可识别的任务序列的程序，但程序常常需要同时完成多个任务。线程对客户端和服务器端应用程序都非常重要。
【C++】多线程同步
目标：MVP
02-21 6831
线程间的同步方法大体可以分为两类：用户模式和内核模式。内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。 用户模式下的方法有：原子操作（例如一个单一的全局变量）、临界区。特点是：同步速度特别快。 内核模式下的方法有：事件、信号量、互斥量。同步速度较慢，但适用性比较好。 **临界区：**通过对多线程的串行化来访问公共资源或一段代码、速度快，适合控制数据访问。 **互斥量：**为协调共同对一个共享资源的单独访问而设计的。 *
深入分析C# 线程同步
12-17
线程同步是多线程编程中的关键概念，用于管理和协调多个线程对共享资源的访问，以避免数据竞争和不一致性。在C#中，线程同步是通过一系列机制实现的，这些机制允许程序员控制线程对共享数据的访问顺序，从而确保数据...
QT 多线程同步QSemaphore
11-26
QT框架中的多线程同步是实现高效并发编程的关键技术，其中`QSemaphore`是一个重要的工具。`QSemaphore`是Qt的并发类库中的一员，它主要用于控制对共享资源的访问，实现线程间的同步和互斥。理解并熟练运用`...
多线程及线程同步
05-21
然而，多线程环境下也带来了一些问题，尤其是资源竞争和数据一致性问题，这些问题需要通过线程同步机制来解决。本文将详细介绍如何通过临界区、互斥内核对象、事件内核对象和信号量内核对象来实现线程同步。 1. ...
java 实现线程同步的方式有哪些
09-05
Java中的线程同步是解决多线程环境下并发访问共享数据可能导致的数据不一致性问题的关键技术。在Java中，有多种方式可以实现线程同步，确保在任何时刻只有一个线程能够访问特定的共享资源。 1. **同步代码块 ...
C#线程同步AutoResetEvent
09-19
在C#编程中，线程同步是一个至关重要的概念，特别是在多线程环境下，它用于控制多个线程对共享资源的访问，确保数据的一致性和程序的正确性。本篇文章将详细探讨`AutoResetEvent`这一线程同步工具，并通过一个DEMO来...
配置Java开发环境
最新发布
Broken_x的博客
07-10 1062
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 267
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1737
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1171
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 342
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 2866
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
qq_44304677的博客
07-09 779
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 602
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 1047
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
Java语言多线程编程讲义
09-14
6. 线程同步与共享访问：为了防止多个线程同时访问同一资源造成数据不一致，Java提供了`synchronized`关键字和`wait()`, `notify()`及`notifyAll()`方法来实现线程间的同步和通信。`synchronized`可以保证在同一时刻...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值