Java第二十天（序列流、字符编码、线程）

最新推荐文章于 2024-05-23 17:45:07 发布
最新推荐文章于 2024-05-23 17:45:07 发布
阅读量65 收藏
点赞数
文章标签： java python 开发工具
原文链接：https://my.oschina.net/u/4110331/blog/3053406
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

88.序列流

注意：写入读取的对象必须实现序列化接口Serializable才可以，否则会报错

一旦序列化的类有改变，之前的序列化就无效了出现报错，类不再匹配，需要设置UID

默认情况下Intellij IDEA关闭了继承了Java.io.Serializable的类生成serialVersionUID的警告，如果需要提示生成serialVersionUID，那么需要做以下设置:在Editor->Inspections下勾选中Java->Serialization issues->Serializable class without ‘serialVersionUID’，将光标放到类名上按Atl＋Enter键就会提示生成serialVersionUID了 

1587fbd34717dbb18e8964f295542678bc6.jpg

a12ad7a11e5df7f7384cc5205e56ba2163a.jpg

import java.io.Serializable;

public class Person implements Serializable{
    //设置UID
    private static final long serialVersionUID = -7911922289599340825L;
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

序列化流

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamDemo {
    public static void main(String[] args) {
        ObjectOutputStream o=null;
        try {
            o=new ObjectOutputStream(new FileOutputStream("person.txt"));
            Person p=new Person("大名",20);
            Person p1=new Person("大华",16);
            Person p2=new Person("小可",12);
            o.writeObject(p);
            o.writeObject(p1);
            o.writeObject(p2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(o!=null){
                try {
                    o.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

反序列化一次只能读取一个，读完了再读就会报错

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputSreamDemo {
    public static void main(String[] args) {
        ObjectInputStream in=null;
        try {
            in=new ObjectInputStream(new FileInputStream("person.txt"));
            Object o=in.readObject();
            Person p=(Person)o;
            System.out.println(p.getName());
            System.out.println(o);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

解决办法，放入集合中

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class ObjectOutputStreamDemo1 {
    public static void main(String[] args) {
        ObjectOutputStream o=null;
        try {
            o=new ObjectOutputStream(new FileOutputStream("person1.txt"));
            List<Person> personlist=new ArrayList<>();
            Person p=new Person("大名",20);
            Person p1=new Person("大华",16);
            Person p2=new Person("小可",12);
            personlist.add(p);
            personlist.add(p1);
            personlist.add(p2);
            o.writeObject(personlist);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(o!=null){
                try {
                    o.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
import sun.text.resources.cldr.om.FormatData_om;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;

public class ObjectInputSreamDemo1 {
    public static void main(String[] args) {
        ObjectInputStream in=null;
        try {
            in=new ObjectInputStream(new FileInputStream("person1.txt"));
            Object o=in.readObject();
            List<Person> p=(List<Person>)o;
            //全部读取
            System.out.println(p);
            //遍历逐个读取
            for (int i = 0; i < p.size(); i++) {
                System.out.println(p.get(i).getName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

89.字符编码

存储:

在计算机中存储字符都是存储的字符所对应的数值以二进制的形式表示。

展示：

去相关的编码表中去查找该值（存储的值）所对应的字符。

一般是默认UTF-8码表

df499540af40cbefe091f977b1d54561ab2.jpg

常用码表：

ASCII表：用7bit来表示存储数据     

ISO-8859-1:拉丁码表， 用8bit来表示     

GB2312: 简体中文编码（国标码）

GBK：gb2312做了增强

GB18030：对GBK做了增强

BIG5：支持繁体

Unicode：支持多种国家的语言，这是国际标准。用2个字节来存储。 不管是什么字符都用2个字节，会有浪费。

UTF-8: 支持多种国家的语言，针对不同的字符的范围给出不同的字节表示。0,a,A用一个字符存储；中间的范围用二个字节 ；中文就使用3个字节。       

 写入的编码和读取的编码必须要一致，否则会有乱码。

90.线程

重点：（1）熟练掌握线程的两种实现方式，第一种必须声明为Thread的的子类重写run方法，run()是线程执行的逻辑体，启动线程是异步启动调用start()，可以通过调用getName()获得线程的名字；第二种创建方法是实现Runable接口，实现run方法重写，将子类作为参数传入线程对象的创建中；

（2）线程的生命周期：

0566ff64ca706ef5f83ae845ad7abe20d28.jpg

（3）线程中出现的问题：并发问题使用同步代码，需要满足：代码被多个线程访问，代码中有共享的数据，共享数据被多条语句操作。

单独作为代码块，可以放在方法中，return的位置不受影响，语法:

synchronized(锁对象){

//操作共享资源的代码

}

修饰在方法上注意两种线程创建方式的不同

（4）休眠：在做服务器端的程序的时候都需要给一个休眠的时间，在没有synchronized代码块里面会让出cpu的资源。有sychronized代码块里面继续占用CPU资源

（5）线程间的通信；

注意：

1.线程间的通信共享数据一定要有同步代码块synchronized

2.一定要有wait和notify，而且二者一定是成对出现。

3.生产者和消费者的线程实现一定是在while（true）里面

（6）设置优先级setPriority(Thread.MAX_PRIORITY)，优先执行

（7）线程的加入，join()，必须放在需要优先执行的线程start()下面

（8）让出线程，Thread.yield()

（9）守护线程，主线程结束，线程也不再继续执行，setDaemon(true)

（10）死锁，线程锁里面的线程锁，需要避免的

package s20190523;

public class MyThread extends Thread{
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.name+" 正在加载  "+i+"%!");
            try {
                //休眠，让出CPU资源
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t=new MyThread("逗鸟外传萌宝大作战");
        MyThread t1=new MyThread("我不喜欢这世界我只喜欢你");
        t.start();
        t1.start();

    }
}
public class MyThread1 implements Runnable{
    private String name;

    public MyThread1(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(name+" 正在加载  "+i+"%!");
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t=new Thread(new MyThread1("逗鸟外传萌宝大作战"));
        Thread  t1=new Thread (new MyThread1("我不喜欢这世界我只喜欢你"));
        t.start();
        t1.start();
    }
}
public class SaleTickets extends Thread{
    //定义共享资源属性为类属性
    static int ticket=100;
    private String name;
    //定义创建锁对象,这个对象是多个线程对象共享的数据
    static Object obj=new Object();

    public SaleTickets(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        //同步代码避免并发问题
        while(true){
            synchronized (obj){
                if(ticket>0){
                    System.out.println(this.name+"售出座位号"+(ticket--)+"火车票！");
                }else{
                    break;
                }
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(this.name+"售罄！");
    }
}
public class SaleTicketsTest {
    public static void main(String[] args) {
        SaleTickets s1=new SaleTickets("1号售票口");
        SaleTickets s2=new SaleTickets("2号售票口");
        SaleTickets s3=new SaleTickets("3号售票口");
        SaleTickets s4=new SaleTickets("4号售票口");
        s1.start();
        s2.start();
        s3.start();
        s4.start();
    }

}

另一种方法，注意synchronized修饰在对象方法上

public class SaleTickets1 implements Runnable {
    //定义共享资源属性
    int ticket = 100;

    //定义创建锁对象
    Object obj = new Object();

    public void run() {
        //卖票是持续的
        while (true){
            //调用synchronized修饰的对象方法
            if (saleTickets()) {
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //synchronized修饰在对象方法上
    public synchronized boolean saleTickets(){
        boolean flag=false;
        if(ticket>0){
            System.out.println(Thread.currentThread().getName() + "卖出座位号为" + (ticket--) + "的票");
        }else{
            System.out.println(Thread.currentThread().getName()+"售罄！");
            flag=true;
        }
        return flag;
    }

}
public class SaleTicketsTest1 {
    public static void main(String[] args) {
        SaleTickets1 s=new SaleTickets1();
        Thread s1=new Thread(s,"1号售票口");
        Thread s2=new Thread(s,"2号售票口");
        Thread s3=new Thread(s,"3号售票口");
        Thread s4=new Thread(s,"4号售票口");
        s1.start();
        s2.start();
        s3.start();
        s4.start();
    }
}
public class Basket {
    //设置一个篮子是否为空的属性
    private boolean isEmpty;
    //解封这个属性设置
    public void setEmpty(boolean empty) {
        isEmpty = empty;
    }
    //创建篮子是否为空的方法
    public boolean isEmpty() {
        return isEmpty;
    }
}
public class Producer extends Thread{
    Basket basket=new Basket();

    public Producer(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void run() {
        //一定是在while（true）之内的
        while (true){
            synchronized (basket){
                try {
                    if(!(basket.isEmpty())){
                        //wait（）线程等待
                        basket.wait();
                    }else{
                        System.out.println("生产者生产水果！");
                        //注意设置篮子状态不为空
                        basket.setEmpty(false);
                        //与wait（）成对出现唤醒线程，提醒消费者消费
                        basket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Buyer extends Thread{
    private Basket basket=new Basket();

    public Buyer(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void run() {
        while (true){
            synchronized (basket){
                try {
                    if(basket.isEmpty()){
                        basket.wait();
                    }else{
                        System.out.println("消费者购买水果！");
                        //注意设置篮子状态为空
                        basket.setEmpty(true);
                        basket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        Basket basket=new Basket();
        Producer p=new Producer(basket);
        Buyer b=new Buyer(basket);
        p.start();
        b.start();
    }
}

另一种方法

public class Basket {
    //设置一个篮子是否为空的属性
    private boolean isEmpty;
    //解封这个属性设置
    public void setEmpty(boolean empty) {
        isEmpty = empty;
    }
    //创建篮子是否为空的方法
    public boolean isEmpty() {
        return isEmpty;
    }
}
public class Producer1 implements Runnable{
    private Basket basket;

    public Producer1(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void run() {
        //一定是在while（true）之内的
        while (true){
            synchronized (basket){
                try {
                    if(!(basket.isEmpty())){
                        //wait（）线程等待
                        basket.wait();
                    }else{
                        System.out.println("生产者生产水果！");
                        //注意设置篮子状态不为空
                        basket.setEmpty(false);
                        //与wait（）成对出现唤醒线程，提醒消费者消费
                        basket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Buyer1 implements Runnable{
    private Basket basket;

    public Buyer1(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void run() {
        while (true){
            synchronized (basket){
                try {
                    if(basket.isEmpty()){
                        basket.wait();
                    }else{
                        System.out.println("消费者购买水果！");
                        //注意设置篮子状态为空
                        basket.setEmpty(true);
                        basket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        Basket basket=new Basket();
        Producer p=new Producer(basket);
        Buyer b=new Buyer(basket);
        Thread t1=new Thread(p);
        Thread t2=new Thread(b);
        t1.start();
        t2.start();
    }
}

2f7e332b60ba1a7e8ce7b53c7777db96973.jpg

public class MyThread extends Thread{
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.name+" 正在加载  "+i+"%!");
            try {
                //休眠，在没有synchronized代码块里面会让出cpu的资源。有sychronized代码块里面继续占用CPU资源
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class MyThreadTest {
    public static void main(String[] args) {
        MyThread t1=new MyThread("逗鸟外传萌宝大作战");
        MyThread t2=new MyThread("我不喜欢这世界我只喜欢你");
        MyThread t3=new MyThread("冰雪传奇");
        MyThread t4=new MyThread("沥川往事");
//        设置优先级
        t4.setPriority(Thread.MAX_PRIORITY);

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

    }
}

84c0c7aa56080b982d660364de405e10d43.jpg

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread t1=new MyThread("逗鸟外传萌宝大作战");
        MyThread t2=new MyThread("我不喜欢这世界我只喜欢你");
        MyThread t3=new MyThread("冰雪传奇");
        MyThread t4=new MyThread("沥川往事");

        t2.start();
        try {
//线程加入必须放在需要优先的线程start后面才有效
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.start();

        t3.start();
        t4.start();

    }
}

fc48d8059ecaf200a041a89324b822ea097.jpg

f8a25efaa14a394e7a18a9f9868d7a2f4e1.jpg

import s20190523.MyThread;

public class MyThreadTest1 {
    public static void main(String[] args) {
        MyThread t1=new MyThread("逗鸟外传萌宝大作战");
        //设置守护线程，线程随主线程结束而结束
        t1.setDaemon(true);
        t1.start();
        System.out.println("主线程结束");

    }
}

6d06736774b6665a092079b613eb0a38916.jpg

public class Lock {
    static Lock lock1=new Lock();
    static Lock lock2=new Lock();
}
public class DeadLock extends Thread{
    int flag;
    @Override
    public void run() {
        if (flag==1){
            synchronized (Lock.lock1){
                System.out.println("进入锁1");
                synchronized (Lock.lock2){
                    System.out.println("进入锁1中的锁2");
                }
            }
        }else{
            synchronized (Lock.lock2){
                System.out.println("进入锁2");
                synchronized (Lock.lock1){
                    System.out.println("进入锁2中的锁1");
                }
            }
        }

    }
}
public class DeadLockTest {
    public static void main(String[] args) {
        DeadLock l1=new DeadLock();
        DeadLock l2=new DeadLock();
        l1.flag=1;
        l1.start();
        l2.start();
    }
}

92e847e5fb6ef833b23495fc23ea84bbd2c.jpg

转载于:https://my.oschina.net/u/4110331/blog/3053406

weixin_34025151
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 14万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java字符串
m0_51779342的博客
09-14 2355
字符串是由多个字符组成的一串数据（字符序列），它可以看成是一个字符数组。Java程序中的所有字符串面值（如："abc"）都可以看成是一个字符串对象
java io 多线程_JavaIO流操作及多线程
weixin_30762173的博客
02-13 894
Java IO 流操作及多线程• JAVA流的概念• 字符输入输出流• 字节输入输出流• JAVA中文件与目录管理• 线程基本概念• 线程同步• 线程死锁• 线程挂起、恢复与终止1 、Java 流的概念流(Stream)是指在计算机的输入输出操作中各部件之间的数据流动。按照数据的传输方向，流可分为输入流与输出流。Java语言里的流序列中的数据既可以是未经加工的原始二进制数据，也可以是经过一定编码处...
第十三章 Java 文件与流
Bennettgxd的博客
08-31 683
第十三章 Java 文件与流
java序列化框架全集讲解
weixin_43114209的博客
08-04 1万+
Java序列化框架是一种用于在Java应用程序中将对象转换为字节流或从字节流反序列化为对象的工具。序列化是将对象的状态转换为字节流的过程，以便可以将其存储在文件中、通过网络传输或在不同的系统之间共享。反序列化是将字节流转换回对象的过程。Java序列化框架的主要目的是简化对象的序列化和反序列化过程，使开发人员可以更轻松地将对象保存到持久存储中，或者在分布式系统中传输对象。这些框架通常提供了高级功能，如版本控制、自定义序列化方式、压缩和加密等。
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
1、【java线程及线程池系列】java线程及线程池概念详解
alanchanchn的专栏
06-12 3万+
缓冲队列长度的设置，按照一般的理解应该设置成maximumPoolSize的5倍，因为单个线程在不切换cpu的情况下是单个cpu运算一个线程，corePoolSize设置成和cpu一样的数量，maximumPoolSize设置成cpu的2倍，避免cpu处于空闲状态则直接加入一旦cpu空闲理解执行的线程数量，同时由于cpu的速度较快以及有请求执行的线程加入缓冲队列中减少cpu等待时间，故将缓冲队列设置大一些。线程池存在的目的在于提前创建好需要的线程，减少临时创建线程带来的资源消耗。
Java基础(三)之多线程与 IO
faramita_of_mine的博客
03-12 1436
Java基础之多线程与 IO一、进程与线程二、多线程编程之继承 Thread三、实现 Runnable 接口四、线程的同步五、死锁六、IO七、文件对象 File八、字节输入流 FileInputStream九、字节输出流 FileOutputStream十、字符流 FileReader 和 FileWriter十一、缓冲字符流 BufferedReader 和 BufferedWriter十二、properties 配置文件的读取十三、对象序列化与反序列化十四、线程的几种可用状态（自） 一、进程与线程   
Java文件处理io流
weixin_45203607的博客
03-31 1367
java文件处理io流 File 文件操作 方法 简介 boolean exists() 判断文件和目录是否存在 boolean isFile() 判断是否是文件 boolean isDirectory() 判断是否是目录 String getPath() 返回当前路径 String getAbsolutePath() 返回此对象的绝对路径 String getName 返回文件名称 String getParent() 返回路径的上
Java编码规范总结
linsa_pursuer的博客
06-25 7634
Java编码规范总结
JAVA上百实例源码以及开源项目
01-03
通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何从...
Java开发详解.zip
09-02
031216_【第12章：JAVA IO】_字符编码笔记.pdf 031217_【第12章：JAVA IO】_对象序列化笔记.pdf 031218_〖第12章：JAVA IO〗_实例操作—单人信息管理程序笔记.pdf 031219_〖第12章：JAVA IO〗_实例操作：投票程序...
JAVA上百实例源码以及开源项目源代码
09-17
通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥,通常应对私钥加密后再保存、如何从...
疯狂JAVA讲义
10-17
第1章 Java概述 1 1.1 Java语言的发展简史 2 1.2 Java的竞争对手及各自优势 4 1.2.1 C#简介和优势 4 1.2.2 Ruby简介和优势 4 1.2.3 Python的简介和优势 5 1.3 Java程序运行机制 5 1.3.1 高级语言的运行机制 6...
java开源包1
06-28
WARTS是一个纯Java数据库工具，可以执行字符编码识别的数据同步。开发它是用于在UTF-8 Oracle实例中使用ASCII编码的Oracle 数据库中来正确的传输非ASCII字符。 Java模板语言 Beetl Beetl,是Bee Template Language的...
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1133
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
Spring Bean Map之舞
m0_51176516的博客
05-23 229
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 287
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
Java高级面试精粹：问题与解答集锦（一）
最新发布
Layla_c的博客
05-23 804
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
java线程安全获取序列
07-11
在 Java 中，可以通过使用锁或原子操作来实现线程安全的序列获取。下面是两种常见的实现方式： 1. 使用锁（Lock）或同步块（Synchronized Block）：通过在获取序列的代码块上加锁或使用同步块，确保在同一时间只有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值