Java线程基础

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量82 收藏
点赞数
分类专栏： java学习 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyb0218_0308/article/details/118191795
版权

多线程

线程相关概念

  • 程序(program)

是为完成特定任务、用某种语言编写的一组指令的集合。

简单的说：就是我们写的代码

  • 进程

    1. 进程是指运行中的程序，比如我们使用的QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间
    2. 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程

  • 线程

    1. 线程由进程创建的，是进程的一个实体
    2. 一个进程可以拥有多个线程

  • 其他相关概念

    1. 单线程：同一个时刻，只允许执行一个线程。
    2. 多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件。
    3. 并发：同一个时刻，多个任务交替执行，造成一种"貌似同时"的错觉，简单的说，单核CPU实现的多任务就是并发。
    4. 并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。
 public static void main(String[] args) {
        Runtime runtime=Runtime.getRuntime();
        //获取当前电脑的cpu数量/核心数
        int cpuNums=runtime.availableProcessors();
        System.out.println("当前有cpu个数="+cpuNums);
    }

线程的基本使用

  • 创建线程的两种方式

在java中线程来使用有两种方法

  1. 继承Thread类，重写run方法

Thread类

//1.当一个类继承了Thread类，该类就可以当做线程使用
//2.我们会重写run方法，写上自己的业务代码
//3.run Thread类 实现了Runnable 接口的run方法
class Cat extends  Thread{
    int times=0;
    @Override
    public void run() {
        while (true){
            //该线程每隔一秒。在控制台输出“喵喵，我是一只小猫咪”
            System.out.println("喵喵，我是一只小猫咪"+(++times));
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times==80){
                break;//当times到80，退出while，这时线程也就退出
            }
        }
    }
}
    public class Thread1 {
    public static void main(String[] args) {
        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();
        cat.start();//启动线程->最终会执行cat的run方法
        cat.run//run方法就是一个普通的方法，并没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
        //说明：当main线程启动一个字线程Thread-0，主线程不会阻塞，会继续执行
        //这时，主线程和子线程是交替执行
    }
}
  • start0()是本地方法，是JVM调用，底层是C/C++实现，真正实现多线程的效果，是start0()，而不是run
  • start()方法调用start0()方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于CPU，有CPU统一调度

实现Runnable接口

  1. 实现Runnable接口，重写run方法
    1. java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了
    2. java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
class Dog implements Runnable{//通过实现接口Runnable来开发线程
    int count=0;
    @Override
    public void run() {
        while (true){
            System.out.println("小狗汪汪叫"+(++count)+Thread.currentThread().getName());
            //休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count==10){
                break;
            }
        }
    }
}
public static void main(String[] args) throws Exception{
        Dog dog = new Dog();
        //dog.start();这里不能调用start
        //创建了Thread对象，把dog对象(实现Runnable)，放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }

//线程代理类，模拟了一个极简的Thread类
class ThreadProxy implements Runnable{
    private Runnable target=null;//属性，类型是Runnable
    @Override
    public void run() {
        if (target!=null){
            target.run();//动态绑定(运行类型)
        }
    }
    public ThreadProxy(Runnable target) {
        this.target = target;
    }
    public void start(){
        start0();//这个方法真正实现了多线程方法
    }
    public void start0(){
        run();
    }
}
  • 继承Thread和实现Runnable的区别
    1. 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable
    2. 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable

线程终止

  • 基本说明
    1. 当线程完成任务后，会自动退出
    2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
//通知方式
class T extends Thread{
    private int count=0;
    //设置一个控制变量
    private boolean loop=true;
    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(50);//让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T运行中"+(++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}
public static void main(String[] args) throws Exception{
        T t = new T();
        t.start();
        //如果希望main线程去控制t线程的终止，必须修改loop
        //让t退出run方法，从而终止t线程->通知方式
        //让主线程休眠10秒，再通知t线程退出
        System.out.println("main线程休眠10s");
        Thread.sleep(10*1000);
        t.setLoop(false);
    }

线程常用方法

  • 常用方法第一组

    1. setName//设置线程名称，使之与参数name相同
    2. getName//返回该线程的名称
    3. start//使该线程开始执行；Java虚拟机底层调用该线程的start0方法
    4. run//调用线程对象run方法
    5. setPriority//更改线程的优先级
    6. getPriority//获取线程的优先级
    7. sleep//在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
    8. interrupt//中断线程

  • 注意事项和细节

    1. satrt底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
    2. 线程优先级的范围
    3. interrupt，中断线程，但并没有真正的结束线程。所有一般用于中断正在休眠线程
    4. sleep：线程的静态方法，使当前线程休眠
class T extends Thread{//自定义的线程类

    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName(获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "吃包子" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName() + "被interrupt");
            }
        }
    }
}
public static void main(String[] args)throws Exception{
        T t = new T();
        t.setName("张三");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();//启动子线程
        //子线程打印5hi，然后就中断，子线程休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi"+i);
        }
        System.out.println(t.getName()+"线程的优先级"+t.getPriority());
        t.interrupt();//当执行到这里，就会中断，t线程的休眠
    }
  • 常用方法第二组
    1. yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
    2. join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插队的线程所有的任务
class T extends Thread{
    @Override
    public void run() {
        for (int i = 01; i <=20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃了"+i+"包子");
        }
    }
}
public static void main(String[] args)throws Exception{
        T t = new T();
        t.start();
        for (int i = 1; i <=20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程吃了"+i+"包子");
            if (i==5){
                System.out.println("主线程让子线程先吃");
                //线程插队
                //t.join();//这里相当于t线程先执行完毕
                Thread.yield();//礼让，不一定成功
                System.out.println("子线程吃完了主线程接着吃");
            }
        }
    }
  • 用户线程和守护线程
    1. 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
    2. 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
    3. 常见的守护线程：垃圾回收机制
class T extends Thread{
    @Override
    public void run() {
        for (; ;) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hello");
        }
    }
}
public static void main(String[] args)throws Exception{
        T t = new T();
        //如果我们希望当main线程结束后，子线程自动结束
        //只需将子线程设置为守护线程即可
        t.setDaemon(true);
        t.start();
        for (int i = 1; i <=10; i++) {
            Thread.sleep(1000);
            System.out.println("hi"+i);
        }
    }

线程的生命周期

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NsoMPxW2-1624524546590)(file:///C:\Users\naizhi\Documents\Tencent Files\1814307395\Image\C2C\SGAQRI]_A]69]{{W{3~R.png)

Synchronized

  • 线程同步机制

    1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
    2. 也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行修改。

  • 同步具体方法

    1. 同步代码块
    synchronized (对象) {//得到对象的锁，才能操作同步代码    //需要被同步代码;}
    1. synchronized还可以放在方法声明中，表示整个方法为同步方法
    public synchronized void m(String name){    //需要被同步的代码;}
    1. 解释：就好像某小伙伴上厕所前先把门关上(上锁)，完事后再出来(解锁)，那么其他小伙伴就可在使用厕所了
//实现接口方式，使用synchronized实现线程同步class SellTicket implements Runnable{    private static int ticketNum=100;//让多个线程共享    private boolean loop=true;//控制run方法变量    public synchronized void sell(){//同步方法,在同一时刻，只能有一个线程来执行sell方法        if (ticketNum<=0){            System.out.println("售票结束");            loop=false;            return;        }        try {            Thread.sleep(50);//休眠50毫秒        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票，"                +"剩余票数="+(--ticketNum));    }    @Override    public void run() {        while (loop) {            sell();//sell方法是一个同步方法        }    }}public static void main(String[] args) {        SellTicket sellTicket = new SellTicket();        new Thread(sellTicket).start();//窗口1        new Thread(sellTicket).start();//窗口2        new Thread(sellTicket).start();//窗口3    }

互斥锁

  • 基本介绍

    1. 在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
    2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
    3. 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
    4. 同步的局限性：导致程序的执行效率要降低
    5. 同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)
    6. 同步方法(静态的)的锁为当前类本身

  • 注意事项和细节

    1. 同步方法如果没有使用static修饰：默认锁对象为this
    2. 如果方法使用static修饰，默认锁对象：当前类.class
    3. 实现的落地步骤：
      • 需要先分析上锁的代码
      • 选择同步代码块或同步方法
      • 要求多个线程的锁对象为同一个即可！
//实现接口方式，使用synchronized实现线程同步class SellTicket implements Runnable{        private static int ticketNum=100;//让多个线程共享        private boolean loop=true;//控制run方法变量        Object object=new Object();    //1.public synchronized static void m1(){}锁是加在SellTicket.class    //2.如果在静态中，实现一个同步代码块    public static void m1(){        synchronized (SellTicket.class){        }    }    //1.public synchronized void sell(){}就是一个同步方法    //2.这时锁在this对象    //3.也可以在代码块上写synchronized，同步代码块，互斥锁还是在this对象    public void sell(){//同步方法,在同一时刻，只能有一个线程来执行sell方法        synchronized (/*this*/object) {            if (ticketNum <= 0) {                System.out.println("售票结束");                loop = false;                return;            }            try {                Thread.sleep(50);//休眠50毫秒            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票，"                    + "剩余票数=" + (--ticketNum));        }    }

线程的死锁

  • 基本介绍

多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程是一定要避免死锁的发生。

class SellTicket extends Thread{    static Object o1=new Object();    static Object o2=new Object();    boolean flag;    public SellTicket(boolean flag) {        this.flag = flag;    }    @Override    public void run() {        //1.如果flag为t，线程A就会先得到/持有o1对象锁，然后尝试去获取o2对象锁        //2.如果线程A得不到o2对象锁，就会Blocked        //3.如果flag为f，线程B就会先得到/持有o2对象锁，然后尝试去获取o1对象锁        //4.如果线程B得不到o1对象锁，就会Blocked        if (flag){            synchronized (o1){//对象互斥锁，下面是同步代码                System.out.println(Thread.currentThread().getName()+"进入1");                synchronized (o2){//这里获得li对象的监视权                    System.out.println(Thread.currentThread().getName()+"进入2");                }            }        }else {            synchronized (o2){                System.out.println(Thread.currentThread().getName()+"进入3");                synchronized (o1){//这里获得li对象的监视权                    System.out.println(Thread.currentThread().getName()+"进入4");                }            }        }    }}public static void main(String[] args) {        //模拟死锁对象        SellTicket A = new SellTicket(true);        A.setName("A线程");        SellTicket B = new SellTicket(false);        B.setName("B线程");        A.start();        B.start();    }

释放锁

  • 下面操作会释放锁

    1. 当前线程的同步方法、同步代码块执行结束

    案例：上厕所，完事出来

    1. 当前线程在同步代码块、同步方法中遇到break、return

    案例：没有正常的完事，经理叫他修改bug，不得已出来

    1. 当前线程在同步代码块、同步方法中出现了未处理的error或exception，导致异常结束

    案例：没有正常的完事，发现忘带纸，不得以出来

    1. 当前线程的同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

    案例：没有正常的完事，觉得需要酝酿下，所以出来等会再进去

  • 下面操作不会释放锁

    1. 线程执行同步方法或同步代码块时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁

    案例：上厕所，太困了，在坑位上眯了一会

    1. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁

    提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

我走后的夜与昼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
java线程基础总结笔记
01-20
1.线程安全 1.1什么是线程安全？ 就是当多个线程访问某一个类（对象或方法)时，这个类（对象或方法)始终都能表现出正确的行为，那么这个类（对象或方法)就是线程安全的。 1.2 synchronized关键字 可以在任意对象及...
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6254
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java基础：Java线程基础
TuT
04-17 3225
操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的...
java线程基础知识总结
星晚的博客
03-04 1万+
本期讲解的是java中关于线程的相关知识点1.创建线程的方式2.线程的优先级3.线程阻塞4.线程的相关方法5.守护线程6.线程池7.多线程并发安全问题7.3静态方法修饰synchronized 1.创建线程的方式 1.1继承Thread类并重写run方法 public class ThreadDemo1 { public static void main(String[] args) { MyThread1 t1 = new MyThread1(); MyThread2 t2 = new My
Java中的线程基础篇-线程基本概念
weixin_44446626的博客
05-08 1808
Java中的线程一、基础知识1. 进程、线程、协程1.1 进程1.2 线程1.3 协程2. 串行、并发、并行2.1 串行2.2 并发2.3 并行二、线程的创建1. 继承Thread类1.1 实现步骤1.2 特点2. 实现Runnable接口2.1 实现步骤2.2 与Thread相比3. 实现Callable接口（JDK5.0新增）3.1 实现步骤3.2 与Runnable接口相比三、线程的常用方法四、线程的生命周期1. 基本概念2. 六个状态 一、基础知识 1. 进程、线程、协程 1.1 进程 基本概念
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java线程系列详解
wang_yong_hui_1234的博客
04-15 4014
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java多线程基础（一）
计蒙不吃鱼的博客
07-19 5832
文章分两份，第一份主要内容为1-4点 1.多线程的概念 2.Java程序运行原理 3.实现多线程的2种方式 4.2种方式的区别 5.线程同步（同步锁） 6.同步线程之间的通讯 1.多线程的概念 （1）并发和并行 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，...
Java线程基础(13):wait()和notify()
mingyuli的博客
07-21 1万+
简介 本文讲解Java中wait()、notify()，通过一个标准的使用实例，来讨论下这两个方法的作用和使用时注意点，这两个方法被提取到顶级父类Object对象中，地位等同于toString()方法。 一、wait()和notify()含义 wait()方法是让当前线程等待的，即让线程释放了对共享对象的锁，不再继续向下执行。 wait(long timeout)方法可以指定一个超时时间，过了这个时间如果没有被notify()唤醒，则函数还是会返回。如果传递一个负数timeout会抛出I...
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java线程基础教程完整版
03-14
通过深入学习和实践这些Java线程基础知识，你可以有效地编写出高效、安全的多线程程序。记住，理解线程的原理和掌握同步机制是关键，这将有助于解决复杂的并发问题。阅读"Java线程.pdf"文档，你将获得更详细、全面的...
golang 接口
m0_70982551的博客
07-24 946
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 513
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 636
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 593
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 361
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java线程基础教程：从入门到进阶
"Java线程基础教程，适合对Java有一定了解但缺乏多线程经验的开发者，由专家Brian Goetz撰写。本教程旨在教授线程基础知识，包括线程的创建、数据交换、控制及通信。" Java线程是Java语言的一个重要特性，它允许在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我走后的夜与昼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值