线程学习（一）

最新推荐文章于 2022-12-20 16:09:35 发布
最新推荐文章于 2022-12-20 16:09:35 发布
阅读量184 收藏
点赞数
分类专栏： JAVA学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43153155/article/details/99223500
版权

线程学习

案例描述：你和你女朋友公用一张银行卡，你向银行卡中存钱、你女朋友取钱

初级应用：使用Runnable实现线程


public class Test {
    public static void main(String[] args) {
        //1创建银行卡
        BankCard card = new BankCard();//0
        //2创建存钱和取钱功能
        AddMoney add = new AddMoney(card);
        SubMoney sub = new SubMoney(card);
        //3创建线程对象
        Thread shaobao = new Thread(add, "少泊");
        Thread xiaohai = new Thread(sub, "小海");
        //4启动
        shaobao.start();
        xiaohai.start();
    }
}



public class BankCard {
    private double money;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}



public class AddMoney implements Runnable {
    private BankCard card;

    public AddMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        //存
        for (int i = 0; i < 10; i++) {
            card.setMoney(card.getMoney() + 1000);
            System.out.println(Thread.currentThread().getName() + "存了1000元，余额是:" + card.getMoney());
        }
    }
}



public class SubMoney implements Runnable {
    private BankCard card;

    public SubMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        //取
        for (int i = 0; i < 10; i++) {
            if (card.getMoney() >= 1000) {
                card.setMoney(card.getMoney() - 1000);
                System.out.println(Thread.currentThread().getName() + "取了1000,余额是:" + card.getMoney());
            } else {
                System.out.println("余额不足，及时存钱");
                i--;
            }
        }
    }
}

高级应用

该程序可以进行简化，具体实现如下：

public static void main(String[] args) {
        BankCard card = new BankCard();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    card.setMoney(card.getMoney() + 1000);
                    System.out.println(Thread.currentThread().getName() + "存了1000，余额：" + card.getMoney());
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    if (card.getMoney() >= 1000) {
                        card.setMoney(card.getMoney() - 1000);
                        System.out.println(Thread.currentThread().getName() + "取了1000，余额：" + card.getMoney());
                    } else {
                        System.out.println("余额不足");
                        i--;
                    }
                }
            }
        }).start();
    }



public class BankCard {
    private double money;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

以上代码虽然实现了案例要求，但是会存在 一方还没有存钱，而另一方在不知情的情况下多次去进行取钱的情况，如图：

在这里插入图片描述

为了解决上述问题，我们可以引进线程同步的概念。

同步代码块的使用（同步：Synchronized：有等待）：

语法：
	synchronized(锁) {
		//需要访问临界资源的代码段
	}

	说明：
	a.程序走到代码段中，就用锁来锁住了临界资源，这个时候，其他线程不能执行代码段中的代码，只能在锁外边等待
	b.执行完代码段中的这段代码，会自动解锁。然后剩下的其他线程开始争抢cpu时间片
	c.一定要保证不同的线程看到的是同一把锁，否则同步代码块没有意义

public class AddMoney implements Runnable {
    private BankCard card;

    public AddMoney(BankCard card) {
        this.card = card;
    }

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

                card.setMoney(card.getMoney() + 1000);
                System.out.println(Thread.currentThread().getName() + "存了1000，余额是:" + card.getMoney());

            }
        }

    }
}



public class SubMoney implements Runnable{
    private BankCard card;

    public SubMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            synchronized (card) {
                if (card.getMoney() >= 1000) {
                    card.setMoney(card.getMoney() - 1000);
                    System.out.println(Thread.currentThread().getName() + "取了1000,余额是:" + card.getMoney());
                } else {
                    System.out.println("余额不足");
                    i--;
                }
            }
        }
    }
}



public class BankCard {
    private double money;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}



public static void main(String[] args) {
        BankCard card=new BankCard();
        AddMoney add=new AddMoney(card);
        SubMoney sub=new SubMoney(card);
        new Thread(add,"少泊").start();
        new Thread(sub,"发海").start();
    }

在这里插入图片描述

实现线程同步也可以使用接口Lock来实现，而且更加有效：

从jdk1.5之后加入新的接口 Lock,ReentrantLock（可重入锁）是Lock接口的实现类。
	通过显式定义同步锁对象来实现同步,同步锁提供了比synchronized代码块更广泛的锁定操
	注意：最好将 unlock的操作放到finally块中
	通过使用ReentrantLock这个类来进行锁的操作,它实现了Lock接口，使用ReentrantLock可以显式地加锁、释放锁

public class AddMoney implements Runnable {
    private BankCard card;
    private Lock lock;

    public AddMoney(BankCard card, Lock lock) {
        this.card = card;
        this.lock=lock;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++) {
            lock.lock();
            try {
                card.setMoney(card.getMoney() + 1000);
                System.out.println(Thread.currentThread().getName() + "存了1000，余额是:" + card.getMoney());
            } finally {
                lock.unlock();
            }
        }
    }
}



public class SubMoney implements Runnable{
    private BankCard card;
    private Lock lock;

    public SubMoney(BankCard card,Lock lock) {
        this.card = card;
        this.lock=lock;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
                lock.lock();
            try {
                if (card.getMoney() >= 1000) {
                    card.setMoney(card.getMoney() - 1000);
                    System.out.println(Thread.currentThread().getName() + "取了1000,余额是:" + card.getMoney());
                } else {
                    System.out.println("余额不足");
                    i--;
                }
            } finally {
                lock.unlock();
            }

        }
    }
}



public class BankCard {
    private double money;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}


public static void main(String[] args) {
        BankCard card=new BankCard();
        Lock lock=new ReentrantLock();
        AddMoney add=new AddMoney(card,lock);
        SubMoney sub=new SubMoney(card,lock);
        new Thread(add,"少泊").start();
        new Thread(sub,"发海").start();
    }

线程同步虽然有效的解决了在没存钱时多次取钱的问题，但可以通过运行结果发现，在加入线程锁之后，只能先等一个人做完全部存钱行为后才可以进行取钱。那如何实现有顺序的执行两个不同的操作线程呢？

这时候我们就可以开始学习线程之间的通信，此时我们更改案例需求，将其变为：

你和你朋友公用一张银行卡，你向卡中存钱，你朋友取钱，保证你存一笔，然后取一笔，再存一笔，再取一笔，顺序执行存取操作

实现功能：使用线程通信。
在jdk1.5之前有三个方法实现线程通信:

wait(): 等待，线程执行这个方法进入等待队列（和锁有关，一个锁对应一个等待队列）, 需要被唤醒

notify(): 通知唤醒，从等待队列中随机唤醒一个线程

notifyAll():全部唤醒,把等待队列中所有的线程都唤醒

public class AddMoney implements Runnable{

    private BankCard card;

    public AddMoney(BankCard card) {
        this.card = card;
    }


    @Override
    public void run() {
        for(int i=0;i<10;i++){
            card.save();
        }
    }
}



public class SubMoney implements Runnable {

    private BankCard card;

    public SubMoney(BankCard card) {
        this.card = card;
    }


    @Override
    public void run() {
        for(int i=0;i<10;i++){
            card.take();
        }
    }
}



public class BankCard {
    private double money;
    private boolean flag;//true 有钱，可以取   false没钱 ，可以存


    //存钱
    public synchronized void save(){ //this
        if(flag){//有钱
            try {
                this.wait();//等待,释放cpu，释放锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


        money=money+1000;
        System.out.println(Thread.currentThread().getName()+"存了1000，余额是:"+money);
        flag=true;//修改标记
        this.notify();//唤醒取钱线程

    }


    //取钱
    public synchronized void take(){//this
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        
        
        money=money-1000;
        System.out.println(Thread.currentThread().getName()+"取了1000，余额是:"+money);
        flag=false;//修改标记为false
        this.notify();//通知存钱线程
    }
}



public static void main(String[] args) {
        //1创建card
        BankCard card=new BankCard();
        //2创建存钱和取钱
        AddMoney add=new AddMoney(card);
        SubMoney sub=new SubMoney(card);
        //3创建线程对象
        Thread shaobo=new Thread(add, "少泊");
        Thread fengjie=new Thread(sub,"凤姐");

        shaobo.start();
        fengjie.start();

    }

运行结果如下：

在这里插入图片描述

显然此时我们已经完成了案例的要求，但是此时存钱和取钱的线程各只有一个，那如果我们再添加更多的存取线程后，上述代码还能很好的执行么？我们试着向代码中存取线程各自增加一个新的线程

public static void main(String[] args) {
        //1创建card
        BankCard card=new BankCard();
        //2创建存钱和取钱
        AddMoney add=new AddMoney(card);
        SubMoney sub=new SubMoney(card);
        //3创建线程对象
        Thread shaobo=new Thread(add, "少泊");
        Thread fengjie=new Thread(sub,"凤姐");

        Thread fahai=new Thread(add, "发海");
        Thread bingbing=new Thread(sub, "冰冰");

        shaobo.start();
        fengjie.start();
        fahai.start();
        bingbing.start();

    }

此时的运行结果会出现一个新的状况：

在这里插入图片描述

可以发现，再增加新的线程后，出现了余额为负数的情况，而这种情况明显是错误的，这时该怎么解决呢？

首先，我们先思考这种情况是怎么产生的？

我们用以下步骤来描述问题的发生：

1.存钱线程1 抢到CPU，执行代码，存钱成功，修改标记为true
2.存钱线程2 抢到CPU，执行代码，等待并释放CPU和锁
3.存钱线程1 抢到CPu，执行代码，等待并释放CPU和锁
4.取钱线程1 抢到CPU，执行代码，取钱成功，修改标记为false，唤醒存钱线程   1
5.存钱线程1 抢到CPU，执行代码，存钱成功，修改标记为true，唤醒存钱线程2
6.存钱线程2 抢到CPU，执行代码，存钱成功，修改标记为true，唤醒

我们可以看到上述步骤中，在步骤5和步骤6中，都发生了存钱成功，并且修改标记为true的现象。说明问题就在此处发生，而发生的原因是：在线程进行判断后，不满足条件的线程进入休眠，而当它被唤醒时，判断条件已经完成，线程将会顺序执行代码，即判断标记失效了，我们该怎么处理该问题呢？

解决方法：将条件语句改为while循环

public class BankCard {
    private double money;
    private boolean flag;//true 有钱，可以取   false没钱 ，可以存


    //存钱
    public synchronized void save(){ //this
        while (flag){//有钱
            try {
                this.wait();//等待,释放cpu，释放锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


        money=money+1000;
        System.out.println(Thread.currentThread().getName()+"存了1000，余额是:"+money);
        flag=true;//修改标记
        this.notify();//唤醒取钱线程

    }


    //取钱
    public synchronized void take(){//this
        while (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }



        money=money-1000;
        System.out.println(Thread.currentThread().getName()+"取了1000，余额是:"+money);
        flag=false;//修改标记为false
        this.notify();//通知存钱线程
    }
}

在解决这个问题后，我们再次执行代码，会发现执行正常了，但是多次执行后，会产生一个新的问题：死锁

在这里插入图片描述

此时我们需要重新分析代码的执行过程：

1.存钱线程1 抢到CPU，执行代码，存钱成功，修改标记为true，唤醒
2.存钱线程2 抢到CPU，执行代码，等待并释放CPU和锁
3.存钱线程1 抢到CPU，执行代码，等待并释放CPU和锁
4.取钱线程1 抢到CPU，执行代码，取钱成功，修改标记为false，唤醒存钱线程1
5.取钱线程2 抢到CPU，执行代码，等待并释放CPU和锁
6.取钱线程1 抢到CPU，执行代码，等待并释放CPU和锁
7.存钱线程1 抢到CPU，执行代码，存钱成功，修改标记为true，唤醒存钱线程2
8.存钱线程2 抢到CPU，执行代码，等待并释放CPU和锁
9.存钱线程1 抢到CPU，执行代码，等待并释放CPU和锁

从上述执行步骤可以看到，在执行过程中，四个线程都进入了休眠状态，从而造成死锁现象。

这时，我们就需要使用到notifyAll（）方法

notify()：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态

		·是Object的方法
		·调用方式：对象.notify();
		·表示唤醒 对象 所标记外边在等待的一个线程	

notifyAll():全部唤醒

		·是Object的方法
		·调用方式：对象.notifyAll()
		·表示唤醒  对象 所标记外边等待的所有线程

代码修改为:

public class BankCard {
    private double money;
    private boolean flag;//true 有钱，可以取   false没钱 ，可以存


    //存钱
    public synchronized void save(){ //this
        while (flag){//有钱
            try {
                this.wait();//等待,释放cpu，释放锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


        money=money+1000;
        System.out.println(Thread.currentThread().getName()+"存了1000，余额是:"+money);
        flag=true;//修改标记
        this.notifyAll();//唤醒取钱线程

    }


    //取钱
    public synchronized void take(){//this
        while (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }



        money=money-1000;
        System.out.println(Thread.currentThread().getName()+"取了1000，余额是:"+money);
        flag=false;//修改标记为false
        this.notifyAll();//通知存钱线程
    }
}

money=money+1000;
    System.out.println(Thread.currentThread().getName()+"存了1000，余额是:"+money);
    flag=true;//修改标记
    this.notifyAll();//唤醒取钱线程

}


//取钱
public synchronized void take(){//this
    while (!flag){
        try {
            this.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }



    money=money-1000;
    System.out.println(Thread.currentThread().getName()+"取了1000，余额是:"+money);
    flag=false;//修改标记为false
    this.notifyAll();//通知存钱线程
}

}


这时，一个较为完善的代码就修改成功了
冰凌寒梦
关注
专栏目录
C#多线程学习之(二)操纵一个线程的方法
12-31
本文实例讲述了C#多线程学习之操纵一个线程的方法。分享给大家供大家参考。具体实现方法如下： 下面我们就动手来创建一个线程，使用Thread类创建线程时，只需提供线程入口即可。（线程入口使程序知道该让这个线程干...
labview多线程学习
最新发布
09-03
多线程学习在LabVIEW中的核心概念： 1. **线程与并行执行**：线程是程序中的执行单元，一个进程可以包含一个或多个线程。在LabVIEW中，多线程允许同时执行多个任务，实现程序的并行处理，提高系统的响应速度和整体...
【JavaSE】Java线程
qinjilll的博客
12-20 279
Java的多线程、定时器的理解与应用、并发与并行的理解、六种线程状态
第四章多线程/1-3/05/2-线程实现方式-1_7_2_1到1_7_2_14////20190623修改
renxanshou的博客
06-23 190
目录 1_7_2_01_并发与并行 1_7_2_02_进程概念 1_7_2_03_线程概念 1_7_2_04_线程调度 1_7_2_05_主线程 1_7_2_06_创建多线程程序的第一种方式_创建Thread类的子类 1_7_2_07_多线程原理_随机性打印结果 1_7_2_08_多线程原理_多线程内存图解 1_7_2_09_Thread类的常用方法_获取线程名称 1_7_2_...
JAVA 线程状态
skystep的博客
07-13 114
从源码出发，java.lang.Thread 定义了一个内部枚举 java.lang.Thread.State ，该枚举用于罗列 JAVA 线程的所有状态，分别是NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。 NEW：新建状态，实例化后处于该状态（ new Thread() ) 。 RUNNABLE：可执行状态，调用 start() 之后处于该状态 ，包括准备（ Ready ）和执行 （ Running ）。 BLOCKED： 阻塞状
Java高级篇-----多线程
BUG专业户
07-18 305
Java高级篇-----多线程
银行取钱---验证继承Thread与实现接口Runnable的区别
奕奕她爹爹xueJAVA
04-04 419
银行取钱---验证继承Thread与实现接口Runnable的区别
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
C#多线程学习之(一)多线程的相关概念分析
01-01
本文详细分析了C#多线程学习之多线程的相关概念。分享给大家供大家参考。具体分析如下： 什么是进程？ 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又...
Java基础巩固之线程学习
01-20
一、线程的学习 　线程是程序中执行单个任务的顺序的流程。 　线程创建的两种方式： 　1、继承Thread类 publicstaticvoidmain(String[]args) { //继承Thread类覆盖父类run方法 Threadthread=newThread() { ...
C#多线程学习(二)如何操纵一个线程.pdf
10-24
C#多线程学习（二）如何操纵一个线程 在现代软件开发中，多线程编程是一个非常重要的概念，它允许程序同时执行两个或多个部分，以提高应用程序的效率和响应能力。C# 作为一门现代编程语言，提供了强大的多线程支持...
Java------线程部分（一一 锁之前）
weixin_45504233的博客
08-11 116
1.进程和线程 (1) 进程（Process） 1 正在运行的程序，是一个程序的运行状态和资源占用（内存，CPU）的描述，通过进程 ID区分。 2 进程是程序的一个动态过程,它指的是从代码加载到执行完毕的一个完成过程。 3 目前操作系统支持多进程多任务。 A进程的特点： a.独立性：不同的进程之间是独立的，相互之间资源不共享（举例：两个正在上课的教室有各自的财产，相互之间不共享） b.动态性...
JAVA多线程
qq_37933128的博客
11-22 370
1. 线程概述 1.1 什么是进程 进程是系统进行资源分配的基本单位，也是独立运行的基本单位。 目前操作系统都是支持多进程，可以同时执行多个进程，通过进程ID区分。 单核CPU在同一时刻，只能运行一个进程；宏观并行、微观串行。 1.2 什么是线程 线程又称轻量级进程（Light Weight Process）,它是进程内一个相对独立的、可调度的执行单元，也是CPU的基本调度单位。 一个进程由一个或多个线程组成，彼此间完成不同的工作，同时执行，称为多线程，此处宏观并行、微观串行。 JAVA虚拟机是一个进
Java多线程模拟在同一张银行中取钱存钱
Ethon自动化测试
12-25 2938
/** * 银行卡类 */ public class BankCard { private int balance;//余额 public BankCard(int balance) { super(); this.balance = balance; } public BankCard(){ } public void setBalance(int balan...
第一阶段面试题总结：
weixin_43153155的博客
08-17 1491
面试题总结： 1.一个".java"源文件中是否可以包括多个类？有什么限制？ ​ 一个源文件里可以有多个class声明的类,但只能有一个class被public修饰，且被public修饰的类的类名必须与源文件名相同、 2.垃圾回收器的作用？垃圾回收器可以马上回收内存吗？ ​ Garbage Collection垃圾回收：将不再使用的内存空间应当进行回收。 ​ 1.在C/C++等语言中，由程序员...
Servlet——概述
weixin_43153155的博客
09-05 375
Servlet——概述 文章目录Servlet——概述@[toc]1.Servlet的定义：2.Servlet的基本工作模式3.Servlet简单实现3.1 Servlet核心接口和类<1>Servlet接口：<2>GenericServlet抽象类:<3>HttpServlet类注意：HttpServlet是一个抽象类，但是在源码中可以发现，在该类中并没有抽...
集合小结
weixin_43153155的博客
08-08 213
集合小结 1.集合综述： 1.1集合框架： [外链图片转存失败(img-rTJ4lqeO-1565236373046)(E:\java千峰\第一阶段-pdf\好程序员第一阶段\第11天\集合框架List\Collection集合.png)] [外链图片转存失败(img-81aq4oHx-1565236373047)(E:\java千峰\第一阶段-pdf\好程序员第一阶段\第11天\集合框架List...
JDBC
weixin_43153155的博客
09-01 188
JDBC 文章目录JDBC@[toc]1.JDCBC简介1.1简介1.2JDBC体系结构1.3JDBC核心组件2.JDBC相关的SQL语法对数据库进行操作：对表进行操作：对表的内容进行操作：3.JDBC使用的基本步骤（1）导入jar包（2）注册驱动（3）获取连接（4）执行查询（暂不处理，下一节内容）（5）处理结果（暂不处理，下一节内容）（6）关闭数据库连接4.使用JDBC执行SQL语句4.1St...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值