java se 四大块 之线程（下）

最新推荐文章于 2025-05-01 20:06:47 发布
最新推荐文章于 2025-05-01 20:06:47 发布
阅读量236 收藏
点赞数
分类专栏： Java求学之路 文章标签： java 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_37805671/article/details/78624583
版权 
public class Test{
public   static void main(String []args)   throws  InterrruptedException{
Thread1  t=new Thread1();
Thread  th1=new  Thread(t);
Thread  th2=new  Thread(t);
Thread  th3=new  Thread(t);
Thread  th4=new  Thread(t);
th1.start();
th2.start();
th3.start();
th4.start();
th1.join();
th2.join();
th3.join();
th4.join();
System.out.println("程序结束");
}
}
class Thread1  implements  Runnable{
private  int num=200;
public  void run (){

while (num>0){
System.out.println(Thread.currentThread().getName+"窗口买卖了第"+num+“张票”);
num--;
}
}
}
//上面的程序运行完会有重复的购票可能，可加一个同步代码块或者是同步方法来解决，也就是synchronized关键字 修饰代码块或者方法。

public  class Test{
public static void main(String  []args{
Bank bank=new Bank(fectmoney);
Thread t=new Thread(bank);
t.start();



}
}
class FectMoney  {
private int money=1000;

public synchronized  int getMoney(int number){
if(money>number){
return -1;
}
else if(money>0){
return -2;
}
  else if(number>0){
return  -3;
}else{
try{
Thread.sleep(1000);
}catch(InterruptedException  e){
e.printStackTrace();
mongey -=number;
System.out.println(number);
return money;
}
}

}


}

class Bank   implements  Runnable {

private FectMoney fectmoney;
public Bank(FectMoney fectmoney){
this.fectmoney=fectmoney;
public void run (){
fectmoney.getMoney();

}


}
public class Test {
    public static void main(String[] args) {
        FectMoney fectMoney = new FectMoney();
        Bank bank = new Bank(fectMoney);
        Thread t = new Thread(bank);
        Thread t2 = new Thread(bank);
        t.start();
        t2.start();

    }
}

class FectMoney {
    private int money = 1000;

    public synchronized int getMoney(int number) {
        if (money <number) {
            return -1;
        } else if (money < 0) {
            return -2;
        } else if (number < 0) {
            return -3;
        } else {
            try {
                Thread.sleep(1000);
                money -= number;
                System.out.println(number);
            } catch (InterruptedException e) {
                e.printStackTrace();
                money -= number;
                System.out.println(number);

            }
        }
        return money;
    }

}

class Bank implements Runnable {

    private FectMoney fectmoney;

    public Bank(FectMoney fectmoney) {
        this.fectmoney = fectmoney;
    }

    @Override
    public void run() {

        System.out.println(fectmoney.getMoney(800));

    }

}

}

//一般我们不在run方法上加锁，而是在我们 需要中 的实际功能块上加锁，此例子是证明两个人同时从一个银行账取钱的例子

同步的时候的可能会造成，原因是因为锁 的同步嵌套。两个同步用的不是一把锁，也就是锁的嵌套顺序不一样，死锁的时候，资源不能被共享，请求与保持条件，已经得到线程资源还可以在申请新的资源，已经分配的锁，不能在相应的线程中强行剥夺，在系统中若干线程形成环路，在环路中每个线程都等待相邻线程释放资源。所以尽量不要使用锁的嵌套。容易造成死锁现象。

我说一下单例模式的线程安全时的代码：

public  Test{
public static void main(){
ThreadTest t  =new ThreadTest();
Thread   th1=new Thread(t);
Thread  th2=new Thread (t);
th1.start();
th2.start();
}  
}
class Single{
private staic Single single;
private Single(){}
public static   synchronized  Single getNewInstance(){
if(single==null){
return single =new Single();
}
return single;
}
}
class ThreadTest extends  RUnnable{
@Override
public void  run(){
System.out.println(Single.getNewInstacne());
}
}
//执行结果里面的地址值是一样的。说明也就是线程安全的单例模式,在没有加锁的时候，当我们使用多线程访问单例模式的时候，一个线程在判断single是否为空时，是null，系统又切换到另一个线程，此时在进行判断single是否为空，也是 为空，然后new一个Single（）；而另外一个线程在执行时，他已经判断完了，就会在new一个Single（）；这也就不是但单例模式了，其实线程安全的单例模式的也不是 绝对的安全的，我们任然可以通反射机制来访问单例模式的私有构造器，来破坏单例模式。

public class MainTest
{
    public static void main(String[] args)
    {
        Sample sample = new Sample();

        Thread t1 = new IncreaseThread(sample);
        Thread t2 = new DecreaseThread(sample);

        Thread t3 = new IncreaseThread(sample);
        Thread t4 = new DecreaseThread(sample);

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


 class DecreaseThread extends Thread
{
private Sample sample;

    public DecreaseThread(Sample sample)
    {
        this.sample = sample;
    }

    @Override
    public void run()
    {
        for(int i = 0; i < 20; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            sample.decrease();
        }
    }
}

class IncreaseThread extends Thread
{
    private Sample sample;

    public IncreaseThread(Sample sample)
    {
        this.sample = sample;
    }

    @Override
    public void run()
    {
        for(int i = 0; i < 20; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            sample.increase();
        }
    }

}

class Sample
{
    private int number;

    public synchronized void increase()
    {
        while (0 != number)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        number++;

        System.out.println(number);

        notify();
    }

    public synchronized void decrease()
    {
        while (0 == number)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        number--;

        System.out.println(number);

        notify();
    }
}

//两个线程类  四个线程对象，连个实现增加操作，两个实现减操作，使得数字始终是  1，0 1 0。。。。其中增加了wait方法和notify方法用已在线程之间进行通信。这两个房方法应该放在锁中，当执行到wait方法时，该线程就会释放掉锁，处于等待状态当另一个线程执行到，notify方法时，也会释放锁，并通知处于等待状态的线程继续往下执行。

lock

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MainTest
{
    public static void main(String[] args)
    {
        Sample sample = new Sample();

        Thread t1 = new IncreaseThread(sample);
        Thread t2 = new DecreaseThread(sample);

        Thread t3 = new IncreaseThread(sample);
        Thread t4 = new DecreaseThread(sample);

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


 class DecreaseThread extends Thread
{
private Sample sample;

    public DecreaseThread(Sample sample)
    {
        this.sample = sample;
    }

    @Override
    public void run()
    {
        for(int i = 0; i < 20; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            sample.decrease();
        }
    }
}

class IncreaseThread extends Thread
{
    private Sample sample;

    public IncreaseThread(Sample sample)
    {
        this.sample = sample;
    }

    @Override
    public void run()
    {
        for(int i = 0; i < 20; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            sample.increase();
        }
    }

}


  class Sample {
    private int number;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void increase() {
        lock.lock();
        try {
            while (0 != number) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            number++;

            System.out.println(number);

            condition.signalAll();

        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            lock.unlock();

        }
    }

    public void decrease()

    {
        lock.lock();
        try {
            while (0 == number) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            number--;

            System.out.println(number);

            condition.signalAll();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {
            lock.unlock();
        }
    }
}
JAVA SE面试题及答案整理
Arthur_Altria的博客
03-13 567
适合JAVA初学者观看的JAVA初级面试题及其答案
Java SE重点总结
09-06
Java SE，全称为Java Standard Edition，是Java平台的核心部分，主要面向桌面应用和服务器端开发。这个学习总结涵盖了从基础到高级的Java编程知识点，旨在帮助初学者建立坚实的编程基础，同时也适合有经验的开发者...
模拟高校的三个老师同时分发80份学习笔记
:)一位靓仔偶然路过的博客
09-30 5311
10、模拟高校的三个老师同时分发80份学习笔记，每个老师相当于一个线程。 public class Test01 { public static void main(String[] args) { Teacher t = new Teacher(); new Thread(t, "陈老师").start(); new Thread(t, "高老师").start(); new
线程.学习笔记
MieGod____的博客
12-29 487
线程的四种状态：新建，可运行，阻塞，死亡。
Java se四大块之线程（上）
阿良
11-23 293
一 程序 进程 线程程序：就是静态的代码进程：是正在运行的程序，系统会分配给他内存空间和资源，你打开两个软件时，其实在一个时间点上，只能有一个程序在cpu上运行，电脑是多核，但cpu的个数再多也不能多于进程数 ，你看着两个软件是在同时进行，实际上是电脑在频繁快速切换，一会运行这个程序一会运行另一个，就像是视频一样，其实只是图片，不过图片的快速切换，让你觉着他是一连串的动作。进程有自己的地址空
Java se 四大块之IO
阿良
11-22 494
Java se不分主要包括四大块内容：集合，io，多线程，网络编程。这篇文章主要是介绍IO部分。 1.流的概念 流是字节序列的抽象概念。 文件是数据的静态存储形式，而流是指数据传输时的形态。 流是：字节序列的抽象概念，数据传输的一种数据序列。提供了一种统一的方式向IO设备中读取和写入的方式。 文件是：一些具有永久存储，有序的具有名称的字节的集合。文件是流可操作的IO设备之一。除了文件流
Java多线程——线程创建
爱学习的小段的博客
04-01 305
Process进程与Thread线程 线程创建
Java多线程总结版
weixin_45733740的博客
03-13 723
多线程
Java SE 修炼手册之数据类型和集合
极客星云-优快云博客
10-09 265
这篇博文来聊聊 Java 基础中数据类型和集合的那些事。
Java SE知识点、java基础面试
DAwagua的博客
04-12 112
Java SE基础知识 1、面向对象的四大特征 1、抽象 将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象，只关注有什么，而不关心实现。 2、封装 将数据和对数据的操作包围，只能通过接口对内部数据进行访问，保证了数据的安全性。 3、继承 从已有类中获得属性和方法，创建新的类方法，使得不断更新的软件系统得以延续。 4、多态 允许相同的或者不同子类对象对同一个消息做出不同的响应。必须有继承、重写和父类对象引用子类对象（向上转型）。 2、==、equals和hashcode的联系 1、== 基本类
java SE.docx
01-24
18. **多线程**：Java内置了对多线程的支持，可以通过实现Runnable接口或继承Thread类来创建线程。 19. **IO流**：Java的IO流处理输入输出操作，包括字节流和字符流，以及缓冲流、转换流和对象流等。 20. **反射**...
java八大经典书籍 你看过几本?
08-28
这本书根据Java SE 7全面更新，系统全面讲解Java语言的核心概念、语法、重要特性和开发方法。 三、Java编程思想 《Java编程思想（第4版）》书共22章，包括操作符、控制执行流程、访问权限控制、复用类、多态、接口...
基于ssm的校园外卖配送系统（源码+文档）
luoluoal的博客
04-30 1653
校园外卖配送系统的主要使用者分为：1、用户的功能及权限用户登录注册后，进入系统对个人中心，订单信息管理，订单取消管理，配送接单管理，取消配送管理，送达通知管理等功能进行操作管理。2、配送员的功能及权限用户登录注册后，进入系统对个人中心，订单信息管理，配送接单管理，取消配送管理，送达通知管理等功能进行操作管理。3、管理员的功能及权限用户信息的添加和管理，校园外卖配送详细信息添加和管理和文档信息添加和管理以及网站信息管理，这些都是管理员的功能💕💕作者：落落。
Maven根据Google proto文件自动生成java对象
西木风落
04-29 1967
在分布式系统开发中，Google Protocol Buffers（简称Protobuf）凭借其​​和​​，已成为微服务通信、数据存储等场景的首选协议格式。本文将以Maven为核心工具链，详解如何通过.proto文件自动生成Java对象，并实现与Spring Boot项目的深度集成。
用Java模拟打字：深入解析 java.awt.Robot 的键盘控制艺术
码觉客的博客
04-28 3109
通过，我们可以实现强大的键盘自动化功能。对于简单的字符（英文字母、数字、基础标点等），可以通过模拟单个按键的按下和释放（可能需要配合 Shift 等修饰键）来实现，这需要建立字符到键码的映射并注意按键时序和延迟。对于复杂字符、中文或长文本，由于Robot不理解输入法逻辑，最可靠和常用的方法是将文本复制到系统剪贴板，然后模拟按下系统的粘贴快捷键。无论使用哪种方法，理解Robot的工作原理（模拟物理按键），处理好窗口焦点，并加入适当的延迟，是确保模拟输入成功的关键。虽然Robot。
POI从入门到上手(三)-轻松完成EasyExcel使用,完成Excel导入导出.
最新发布
个人开发经验记事本在此！穿梭于代码世界，积累下满满实战心得。于我而言，开发不仅是技术的打磨，更是经验的沉淀。
05-01 1119
 EasyExcel 是阿里巴巴开源的一个基于 Java 的简单、省内存的读写 Excel 工具。在处理大文件时，它能极大地减少内存占用，并且使用起来相对简单。
Linux 服务管理两种方式service和systemctl
lza20001103的博客
04-29 2859
Linux 服务管理两种方式service和systemctl
Spring框架allow-bean-definition-overriding详细解释
zwh1zwh的博客
04-28 585
Bean@Bean// 覆盖Config1的Bean​默认行为​：启动失败，抛出。​开启覆盖后​：容器中最终注册的是。
Number.isInteger()判断一个数值是否为整数报错
ABCAA1024的博客
04-30 892
NumberUtil.isInteger(String str) 实际上是判断这个字符串是否可以被 安全地解析为 Java 的 Integer 类型（即 32 位有符号整数）。NumberUtil.isInteger(“13787870101”) 返回 false，是因为它超出 Integer 的最大范围，而不是因为它不是纯数字。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值