Java学习 DAY21 线程、锁、网络配置

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量182 收藏
点赞数
分类专栏： java 线程 流 文章标签： 多线程 java 编程语言 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A969910205/article/details/108326801
版权
java 同时被 3 个专栏收录
22 篇文章 0 订阅
订阅专栏
线程
3 篇文章 0 订阅
订阅专栏
流
2 篇文章 0 订阅
订阅专栏

线程之间存在相互抢占，发生在代码的每一步，导致多线程的数据并发安全问题

解决方式—加锁

1.同步代码块锁

synchronized（锁对象）{}

根据锁对象共享进来的线程对象保证在执行代码块内容时不会有抢占
锁对象：一个对象，可以把哪些线程对象共享进来
可以把当前参与的线程对象共享进来的对象
方法区资源（把所有的线程对象都共享）
this(当参与的所有线程对象被Runnable实现类对象共享)

package cn.tedu.thread;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class SellerTicketDemo1 {
    public static void main(String[] args) throws IOException {
        //加载配置文件
        Properties p=new Properties();
        p.load(new FileInputStream("ticket.properties"));
        //根据键来获取值
        String count=p.getProperty("count");

        //创建代表票的类的对象
        Ticket t=new Ticket();
        //设置初始票数
        t.setCount(Integer.parseInt(count));
        //创建代表线程执行信息的类的对象---四个售票员
        Seller s1=new Seller(t);
        Seller s2=new Seller(t );
        Seller s3=new Seller(t);
        Seller s4=new Seller(t);

        //创建四个线程对象（Thread）对象
        Thread t1=new Thread(s1,"A");
        Thread t2=new Thread(s2,"B");
        Thread t3=new Thread(s3,"C");
        Thread t4=new Thread(s4,"D");

        //调用start方法
        t1.start();
        t2.start();
        t3.start();
        t4.start();

        //主线程

    }
}

//定义类---代表线程执行任务信息（卖票）
class Seller implements Runnable{
    //代表票数---共卖100张票
    //static int count=100;
    //声明代表票的类的对象
    private Ticket t;

    //有参构造---保证创建的对象共享一个t对象
    public Seller(Ticket t){
        this.t=t;
    }



    //重写run方法---卖票过程
    @Override
    public void run() {

            //循环实现
            while (true) {
                //同步代码块锁
                //锁对象,给定兑现那个，可以共享哪些线程对象，被共享进来的线程对象
                //被共享进来的线程对象，在代码块内就不会相互抢占
                //synchronized (t) {//t---把当前参与的线程对象共享进来,
                //指定锁对象可以把所有的线程对象共享进来----（方法去资源）
                synchronized (String.class) {
                    // Seller.class  String.class
                    //出循环条件
                    if (t.getCount() == 0) {
                        break;
                    }
                //卖一张票---设置新的剩余票数
                t.setCount(t.getCount() - 1);
                //输出
                //Thread.currentThread()---当前正在执行的线程对象
                System.out.println(Thread.currentThread().getName()
                        + "卖了一张票，还剩余" + t.getCount() + "张票...");
            }
        }
    }
}

//代表票的类
class Ticket{
    //代表票数
    private int count;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

2.同步方法锁
根据锁对象共享进来的线程对象保证在执行方法里内容不会有抢占锁对象
当在非静态方法上加上锁，默认锁对象就是this
当在静态方法上加上锁，默认锁对象就是当前类。class（方法区资源）

package cn.tedu.thread;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class SellerTicketDemo2 {
    public static void main(String[] args) throws IOException {
        //加载配置文件
        Properties p=new Properties();
        p.load(new FileInputStream("ticket.properties"));
        //根据键来获取值
        String count=p.getProperty("count");

        //创建代表票的类的对象
        Ticket t=new Ticket();
        //设置初始票数
        t.setCount(Integer.parseInt(count));
        //创建代表线程执行信息的类的对象---一个售票系统
        Seller2 s1=new Seller2(t);
        /*Seller s1=new Seller(t);
        Seller s2=new Seller(t );
        Seller s3=new Seller(t);
        Seller s4=new Seller(t);*/

        //创建四个线程对象（Thread）对象共享同一个Runnable对象
        Thread t1=new Thread(s1,"A");
        Thread t2=new Thread(s1,"B");
        Thread t3=new Thread(s1,"C");
        Thread t4=new Thread(s1,"D");

        //调用start方法
        t1.start();
        t2.start();
        t3.start();
        t4.start();

        //主线程

    }
}

//定义类---代表线程执行任务信息（卖票）
class Seller2 implements Runnable{
    //代表票数---共卖100张票
    //static int count=100;
    //声明代表票的类的对象
    private Ticket t;
    private static Object obj = new Object();
    //有参构造---保证创建的对象共享一个t对象
    public Seller2(Ticket t){
        this.t=t;
    }



    //重写run方法---卖票过程
    //同步方法锁
    //如果是非静态方法，默认锁对象就是this
    //如果是静态方法，默认锁对象就是当前类.class(方法去资源)
    @Override
    public synchronized void run() {

        //循环实现
        while (true) {
            //同步代码块锁
            //锁对象,给定兑现那个，可以共享哪些线程对象，被共享进来的线程对象
            //被共享进来的线程对象，在代码块内就不会相互抢占
            //synchronized (t) {//t---把当前参与的线程对象共享进来,
            //指定锁对象可以把所有的线程对象共享进来----（方法去资源）
            //synchronized (String.class) {
            // Seller.class  String.class
            //this指代成一个Runnable实现类对象
            //synchronized (obj) {
                //出循环条件
                if (t.getCount() == 0) {
                    break;
                }
                //卖一张票---设置新的剩余票数
                t.setCount(t.getCount() - 1);
                //输出
                //Thread.currentThread()---当前正在执行的线程对象
                System.out.println(Thread.currentThread().getName()
                        + "卖了一张票，还剩余" + t.getCount() + "张票...");
            //}
        }
    }
}


同步：在某个时刻只能由一个线程对象拥有资源（没抢占）
异步：一个资源会被多个线程对象来抢占

同步一定是安全的，异步不一定不安全

死锁
死锁由于锁的嵌套导致死锁问题，通过死锁检测来让其中一个线程对象先执行
package cn.tedu.thread;

public class DeadLockDemo {
    //创建打印的扫描的对象
    private static Scann s=new Scann();
    private static Printer p=new Printer();
    public static void main(String[] args) {
        //员工---先打印再扫描
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (p){
                    p.print();
                    //休眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s){
                        s.scan();
                    }
                }
            }
        });
        //员工---先扫描再打印
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                //
                synchronized (s){
                    s.scan();
                }
                //休眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //打印
                synchronized (p){
                    p.print();
                }
            }
        });

        //开启线程
        t1.start();
        t2.start();
    }
}


//定义代表扫描的类
class Scann{
    public void scan(){
        System.out.println("呼哧呼哧的扫描...");
    }
}

//第一代表打印的类
class Printer{
    public void print(){
        System.out.println("在呼哧呼哧的打印...");
    }
}

等待唤醒机制（结合锁来使用）
通过wait（）、notify（）、notifyAll（）以及标值位来控制线程对象执行顺序

package cn.tedu.thread;

public class WaitNotifyDemo {
    public static void main(String[] args) {
        //商品对象
        Pruduct p=new Pruduct();
        //创建线程对象
        new Thread(new Pruductor(p)).start();//生产者
        new Thread(new Consumer(p)).start();//消费者

    }

}

//定义类---代表线程执行任务信息（生产者）
class Pruductor implements Runnable{
    //声明商品类的对象
    private Pruduct p;

    //有参构造---保证共享同一个商品类的对象
    public Pruductor(Pruduct p){
        this.p=p;
    }
    @Override
    public void run() {
        //保证一直生产下去
        while (true) {
            synchronized (p) {
                if (p.getFlag()==true)
                //让线程对象进行等待
                try {
                    p.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //可以生产的最大值
                int max = 1000 - p.getCount();
                //随机生产的商品数量
                int count = (int) (Math.random() * (max + 1));
                //设置新的剩余的商品数量
                p.setCount(p.getCount() + count);
                //输出
                System.out.println("生产" + count + "个商品，还剩" + p.getCount() + "商品...");

                //唤醒等待线程对象(消费者)
                p.notify();
                //改变布尔值
                p.setFlag(true);
            }
        }
    }
}

//定义类----代表线程执行任务信息（消费者）
class Consumer implements Runnable{
    //
    private Pruduct p;
    //有参构造---保证共享同一个商品类的对象
    public Consumer(Pruduct p){
        this.p=p;
    }
    //指定消费过程
    @Override
    public void run() {
        //保证一直消费下去
        while (true){
            synchronized (p){

                //
                if (p.getFlag()==false)
                //让线程对象进行等待
                try {
                    p.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            //随机消费的商品数量
            int count=(int)(Math.random()*(p.getCount()+1));
            //设置新的剩余商品数量
            p.setCount(p.getCount()-count);
            //输出
            System.out.println("消费了"+count+"个商品，还剩"+p.getCount()+"商品...");

            //唤醒等待的线程对象
                p.notify();
                //改变布尔值
                p.setFlag(false);
            }
        }

    }
}

//代表商品的类
class Pruduct{
    //属性---商品数量
    private int count;

    //标志位
    private boolean flag;

    public boolean getFlag(){
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

wait（）与sleep（）方法的区别
sleep（）：使用时一定要给定休眠时间，到点自然醒。在休眠期间会释放线程对象的CPU的执行权（无论有锁没锁都会释放执行权但是如果有锁不会释放锁对象）。定义在Thread类里的静态方法。
wait（）：使用时可以给定等待时间到点自然醒，但是如果没有指定等待时间需要强制进行唤醒。在等待期间释放线程对象的CPU执行权，释放锁对象。定义在Object类里。

线程的状态：

在这里插入图片描述

线程的优先级（一定程度上避免死锁的发生）

优先级从1到10，优先级级别逐渐增大。理论上优先级越大抢占到资源的概率就越大。
理论上优先级之差大于5那么抢占到的资源的概率会稍微大一点

package cn.tedu.thread;

public class PriorityDemo {
    public static void main(String[] args) {
        //创建线程对象
        Thread t1=new Thread(new PDemo(),"A");
        Thread t2=new Thread(new PDemo(),"B");

        //设置优先级
        t1.setPriority(1);
        t2.setPriority(10);

        //开启线程
        t1.start();
        t2.start();
    }
}


//代表线程执行信息的类
class PDemo implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<=20;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);

            //休眠
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

守护线程

当被守护线程执行结束所有的守护线程随之结束
当被守护线程出现多个时，所有的被守护线程结束，守护线程随之结束。（类加载器—守护线程）

package cn.tedu.thread;

public class DaemonDemo {
    public static void main(String[] args) throws InterruptedException {
        //创建线程对象---四个小兵
        Thread t1=new Thread(new Soldier(),"宫本");
        Thread t2=new Thread(new Soldier(),"亚索");
        Thread t3=new Thread(new Soldier(),"劫");
        Thread t4=new Thread(new Soldier(),"提莫");

        //设置守护线程
        t1.setDaemon(true);
        t2.setDaemon(true);
        t3.setDaemon(true);
        t4.setDaemon(true);

        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();

        //BOSS---主线程---被守护线程
        for(int i=20;i>=0;i--){
            System.out.println("BOSS掉了一滴血，还剩"+i+"滴血...");
            //休眠
            Thread.sleep(5);
        }
    }
}



///代表小兵的类
class Soldier implements Runnable{

    @Override
    public void run() {
        for(int i=10;i>=0;i--){
            //
            System.out.println(Thread.currentThread().getName()
                    +"掉了一滴血，还剩"+i+"滴血...");

            //休眠
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

网络编程（套接字）

基于网络进行数据传输（IO流）

物理层、数据链路层、传输层（UDP、TCP）、会话层、表示层、应用层

IP地址：主机在网络中的位置 IPv4是由0~255的数字组成
域名解析器：把域名解析成对应的IP地址
端口：让计算机和外界进行数据交互的媒介 端口号（065538）从01024端口号基本都被系统占用了，使用时从后面开始使用

蔺江南
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【java 多线程】守护线程与非守护线程的详解
08-26
Java守护线程与非守护线程详解 Java 中有两类线程：User Thread（用户线程）和 Daemon Thread（守护线程）。用户线程即运行在前台的线程，而守护线程是运行在后台的线程。守护线程的作用是为其他前台线程的运行提供...
java计算机课程毕业设计学习源代码day07.zip
07-03
`day07`的主题可能进一步深入到高级主题，如多线程、网络编程、GUI（图形用户界面）开发或者特定的框架如Spring或Hibernate。 6. **软件/插件关联**： 这些文件可能是在IDE（集成开发环境）如Eclipse、IntelliJ ...
Java基础21 多线程线程两种实现方式 锁
Xs943的博客
02-17 1064
多线程的概念 1.程序 ：一个固定逻辑与数据的集合 就称为程序 例如淘宝 贪吃蛇小游戏 2.CPU: 中央处理器 主要用于协调程序与硬件进行配置的工作 3.并发与并行 1.并发（高并发） 在同一个时间段 执行两个或者多个任务 单核cpu 是进行相互切换 执行某一个任务 切换速度是非常快 很容易误解是同时执行的 其实是交替执行 2.并行 在同一时刻 执行两个或者是多个任务的时候 多核cpu是同时执行多个任务 同时执行 目前的电脑都是使用多核 例子: 可以听歌 敲代码 看视频 1.进程: 运行在内存中的程序
Java基础学习Day14--多线程
qq_45732338的博客
07-06 641
Java基础学习Day14--多线程
Day19--Java多线程编程入门学习
gitee_nanzhi66的博客
08-06 1036
多线程是一种并发编程技术，它允许程序同时执行多个线程。线程是程序执行的基本单位，一个程序至少有一个线程，即主线程。通过使用多线程，可以在一个程序中同时处理多个任务，提高程序的效率和响应能力。多线程编程是Java中一个强大的特性，它能够提高程序的性能和响应能力。了解如何创建和管理线程，以及如何处理线程同步和通信，是编写高效并发程序的关键。掌握这些基础知识后，你可以进一步学习更高级的并发工具和设计模式，如线程池、并发集合等。
Java学习路线：day18 多线程
杨丙寅
05-18 1527
文章目录第8章 多线程基本概念：程序、进程、线程进程与线程使用多线程的优点何时需要多线程线程的创建和使用线程的创建和启动Thread类API中创建线程的两种方式创建多线程的方式一：继承Thread类创建过程中的两个问题说明练习1Thread类的有关方法线程的调度线程的优先级练习2练习3创建多线程的方式二：实现Runnable接口继承方式和实现方式的联系与区别补充：线程的分类 原文：https:/...
【JAVA-Day79】 线程死锁讲解
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
02-15 2万+
线程死锁是多线程编程中一种常见的问题，它发生在多个线程互相持有对方所需的资源而无法继续执行的情况下。要避免线程死锁，需要注意线程之间资源的获取顺序和释放顺序，以及避免循环等待的情况发生。
Java进阶学习|Day4.Java多线程,线程池
weixin_60364343的博客
07-01 1311
多线程其实就是,老板请多个员工同时做事,一个进程就相当于一个项目组去做一个项目,多个线程组成了一个进程,就相当于这个项目组有多个员工同时做事.
Java学习路线：day19 多线程2
杨丙寅
05-18 2208
文章目录第8章 多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全问题同步方法处理实现Runnable的线程安全问题同步方法处理继承Thread类的线程安全问题线程安全的单例模式之懒汉式死锁的问题Lock锁方式解决线程安全问题线程的通信sleep()和wait()的异同经典例题：生产者/消费者问题JDK5.0新增线程创建方式创建多线程的方式三：实现Callable接口使用线程池的好处创建多线程的方式四：使用线程池 原文：https://
Java多线程Day19-JUC锁之公平锁
攻城狮Chova的博客
03-01 557
公平锁基本概念AQS锁CLH队列CAS函数ReentrantLock 基本概念 AQS锁 AQS: AbstractQueuedSynchronizer AQS是Java中管理锁的抽象类,包含锁实现的公共方法 AQS是独占锁和共享锁的公共父类 AQS锁的类别: 独占锁: 锁在一个时间点只会被一个线程所占有 根据锁的获取机制,独占锁又分为公平锁和非公平锁 公平锁: 通过CLH等待线程队列按照先来先得的规则,公平地获取锁 非公平锁: 当线程需要获取锁时,无视CLH等待线程队列直接获取锁
Java学习Day9
m0_63651681的博客
07-24 794
非公平锁指多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。非公平锁的优点在于其相对更高的吞吐量，因为允许某些线程获取锁的机会更高，但是其缺点是可能导致某些线程长期无法获取锁，不公平性较高。当一个线程请求锁时，如果锁当前被其他线程占用，请求线程会被放入一个队列中，排队等待锁的释放。多线程可见性问题：在多线程环境中，线程私有的缓存可能会导致一个线程修改了变量的值，但其他线程并不能立即看到修改后的值，从而引发错误的操作或结果不一致的问题。
Java学习Day10
m0_63651681的博客
07-25 650
当使用notify()或notifyAll()方法唤醒等待中的线程时，必须持有与该线程等待时使用的对象锁相同的对象锁。如果提交的任务数超过了核心线程数，线程池可能会创建额外的线程来处理任务，直到达到最大线程数。当你提交一个任务给线程池或者使用其他的执行框架时，会得到一个 Future 对象，该对象可以用来获取任务的执行结果或者取消任务的执行。当一个线程调用对象的wait()方法时，它会释放持有的对象锁，并进入等待状态（等待其他线程调用对象的notify()或notifyAll()方法唤醒它）。
我的java学习日志day01
01-03
【Java学习日志Day01】——初识Java与编程环境搭建 在开始我们的Java学习之旅之前，首先要明确Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）于1995年发布。Java的设计理念是...
java计算机课程毕业设计学习源代码day09.7z
07-03
在这个“day09”主题的学习源代码中，我们可以看到一系列与Java图形用户界面（GUI）设计相关的类和资源文件。下面将对这些文件及其可能涉及的知识点进行详细的解释。 1. **Info.class、Progress2.class、Progress....
java EE学习总结 第六周（包含思维导图）
12-22
Day26 异常 异常的概念 异常在运行过程中出现特殊的情况 异常处理的必要性：任何程序都可能存在大量的未知问题、错误；如果不对这些问题进行正确的处理，则可能导致程序的中断，造成不必要的损失 异常的分类 ...
JAVA进阶补充
2301_80150315的博客
08-15 873
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 566
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1041
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 343
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值