线程同步--synchronized详解

最新推荐文章于 2024-04-14 11:32:36 发布
最新推荐文章于 2024-04-14 11:32:36 发布
阅读量352 收藏
点赞数
分类专栏： JAVA 文章标签： 同步 异步 同步原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30493075/article/details/77268832
版权

在Java的多线程中有两种编程模型：异步编程模型和同步编程模型。
假设t1和t2为两个线程，则
异步编程模型： t1线程执行t1的，t2线程执行t2的，两个线程之间谁也不等谁
同步编程模型：t1线程和t2线程执行，当t1线程必须等t2线程之行结束之后，t1线程才能执行，这是同步编程模型。

为什么要引入同步呢？
为了数据的安全。尽管应用程序的使用率降低，但是为了保证数据是安全的，必须加入线程同步机制。 线程同步机制使程序变成了(等同于)单线程。

什么时候要同步呢？
第一、必须是多线程环境
第二、共享同一个数据 [ 注意：该数据必须是类中的变量（也即实例变量）对应的数据]
第三、共享的数据涉及到修改操作
必须同时满足上面的三个条件才用同步模型。

以下示例演示采用异步编程对共享数据进行修改操作，看会出现什么问题？

/*
 * 以下程序演示取款例子，在不使用线程同步机制，
 * 多线程同时对同一个账户进行操作，会出现什么问题？
 * 
 */
public class Test {

    public static void main(String[] args) throws InterruptedException {
        // 创建一个公共账户
        Account act = new Account("num-001", 1000.0);
        MyRunnable myRunnable = new MyRunnable(act);
        // 创建两个线程，对同一个账户取款
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);

        t1.start();
        t2.start();

    }
}

class MyRunnable implements Runnable {
    Account act;

    public MyRunnable(Account act) {
        this.act = act;
    }

    @Override
    public void run() {
        act.withdraw(100.0);
        System.out.println("取款100.0成功，余额为：" + act.getBalance());

    }

}

class Account {
    private String actnum;
    private Double balance;

    public Account(String actnum, double balance) {
        this.actnum = actnum;
        this.balance = balance;
    }

    public String getActnum() {
        return actnum;
    }

    public void setActnum(String actnum) {
        this.actnum = actnum;
    }

    public Double getBalance() {
        return balance;
    }

    public void setBalance(Double balance) {
        this.balance = balance;
    }

    // 对外提供一个取款的方法
    public void withdraw(double money) {
        // 计算余额
        double after = balance - money;
        // 延迟
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 更新
        this.setBalance(after);

    }

}

运行结果如图 6-1 所示：
这里写图片描述

图 6-1 不使用同步对共享数据进行修改操作会出现“脏读”

使用同步可以解决上述问题。同步的方式大概可以分为两种：同步方法和同步语句块。下面分别用这两种方式解决上述问题。
先用同步语句块解决，对上面的代码做如下修改

//把需要同步的代码放到同步语句块中
        synchronized (this) {
            // 计算余额
            double after = balance - money;
            // 延迟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 更新
            this.setBalance(after);
        }

运行结果如图 6-2 所示
这里写图片描述

图 6-2 使用同步语句块解决

然后用同步方法解决，对上面的代码做如下修改

// 对外提供一个取款的方法，在方法上加上synchronized关键词
    public synchronized void withdraw(double money) {
            // 计算余额
            double after = balance - money;
            // 延迟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 更新
            this.setBalance(after);



    }

运行结果如图 6-3 所示
这里写图片描述

图 6-3 使用同步方法解决

使用synchronized(this)语句块同步的原理：t1线程和t2线程
t1线程在执行过程中，遇到了synchronized关键字，就会去找this的对象锁， 如果找到this对象锁，则进入同步语句块中执行程序。当同步语句块中的代码执行结束后， t1线程归还this的对象锁。

在t1线程执行同步语句块的过程中，如果t2线程也过来执行以下代码，也遇到synchronized 关键字，所以也去找this的对象锁，但是该对象锁被t1线程持有，只能在这等待this对象的归还。

使用synchronized方法同步的原理：t1线程和t2线程
每个对象都有一个锁(也称监控器monitor)，它是对象生来就有的东西(因此你不必为此写任何代码)。
t1线程在执行过程中，遇到了synchronized方法，就会去找this的对象锁， 如果找到this对象锁，这个对象就被锁住了。当同步方法执行结束后，t1线程归还这个对象的对象锁，在方法返回并且解锁之前，谁也不能调用同一个对象的其它synchronized方法。

在t1线程执行同步方法中的代码过程中，如果t2线程也过来执行以下代码，也遇到synchronized 关键字，所以也去找this的对象锁，但是该对象锁被t1线程持有，只能在这等待this对象的归还。

同步方法又能细分为：普通同步方法和静态同步方法。虽然这两种方法同步效果一样，但是本质却是不同的：synchronized关键字加到static静态方法上是给Class类上锁，而synchronized关键字加到普通方法上是给对象上锁。下面用一个示例验证不是同一个锁

/*
 * 验证静态同步方法和普通同步方法的本质区别：
 * 静态同步方法是给Class类上锁，普通同步方法是给对象上锁。
 */
public class Test {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        MyRunnableA myRunnableA = new MyRunnableA(service);
        Thread a = new Thread(myRunnableA);
        a.setName("A");
        a.start();

        MyRunnableB myRunnableB = new MyRunnableB(service);
        Thread b = new Thread(myRunnableB);
        b.setName("B");
        b.start();

        MyRunnableC myRunnableC = new MyRunnableC(service);
        Thread c = new Thread(myRunnableC);
        c.setName("C");
        c.start();

    }
}

class MyRunnableA implements Runnable {
    private Service service;

    public MyRunnableA(Service service) {
        this.service = service;

    }

    @Override
    public void run() {
        service.printA();
    }

}

class MyRunnableB implements Runnable {
    private Service service;

    public MyRunnableB(Service service) {
        this.service = service;

    }

    @Override
    public void run() {
        service.printB();
    }

}

class MyRunnableC implements Runnable {
    private Service service;

    public MyRunnableC(Service service) {
        this.service = service;

    }

    @Override
    public void run() {
        service.printC();
    }

}

/*
 * 提供两个静态同步方法和一个普通同步方法，通过输出结果(异步或同步)来判断是否是不同的锁
 */
class Service {
    public synchronized static void printA() {
        try {
            System.out.println(
                    "线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printA");
            // 设置延迟
            Thread.sleep(3000);
            System.out.println(
                    "线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void printB() {

        System.out.println("线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printB");
    }

    public synchronized void printC() {
        System.out.println("线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printC");
        System.out.println("线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printC");

    }

}

运行结果如图 6-4 所示：
这里写图片描述

图 6-4 方法printC()为异步执行

异步的原因是持有不同的锁，printC()方法是对象锁，printA()方法是Class锁，而Class锁可以对类的所有对象实例起作用。下面用一个示例进行验证

/*
 * 验证Class锁可以对类的所有对象实例起作用
 */
public class Test {

    public static void main(String[] args) throws InterruptedException {
        // 设置两个不同的对象实例
        Service service1 = new Service();
        Service service2 = new Service();
        MyRunnableA myRunnableA = new MyRunnableA(service1);
        Thread a = new Thread(myRunnableA);
        a.setName("A");
        a.start();

        MyRunnableB myRunnableB = new MyRunnableB(service2);
        Thread b = new Thread(myRunnableB);
        b.setName("B");
        b.start();
    }
}

class MyRunnableA implements Runnable {
    private Service service;

    public MyRunnableA(Service service) {
        this.service = service;

    }

    @Override
    public void run() {
        service.printA();
    }

}

class MyRunnableB implements Runnable {
    private Service service;

    public MyRunnableB(Service service) {
        this.service = service;

    }

    @Override
    public void run() {
        service.printB();
    }

}

/*
 * 提供两个静态同步方法
 */
class Service {
    public synchronized static void printA() {
        try {
            System.out.println(
                    "线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printA");
            // 设置延迟
            Thread.sleep(3000);
            System.out.println(
                    "线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void printB() {

        System.out.println("线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printB");
    }

}

运行结果如同 6-5 所示
这里写图片描述

图 6-5 虽然是不同对象，但静态同步方法还是同步执行

同步语句块又能细分为：同步synchronized（class）语句块、同步synchronized（this）语句块、同步synchronized（非this对象x）语句块和同步synchronized（string）语句块。
同步synchronized（this）语句块在上面已经演示过，下面不再演示。
同步synchronized（class）语句块的作用其实和synchronized static方法的作用一样，下面用一个示例进行演示
对图 6-5 上面的代码做以下更改

class Service {
    public static void printA() {
        synchronized (Service.class) {
            try {
                System.out.println(
                        "线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printA");
                // 设置延迟
                Thread.sleep(3000);
                System.out.println(
                        "线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printA");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public synchronized static void printB() {
        synchronized (Service.class) {
            System.out.println(
                    "线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printB");
            System.out.println(
                    "线程名称为:" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printB");
        }
    }

}

运行结果如同 6-6 所示
这里写图片描述

图 6-6 和静态同步方法的作用一样，也是同步执行

同步synchronized（string）语句块会因为String常量池的特性而带来问题，因此同步synchronized 语句块都不使用String作为锁对象，而改用其它，比如new Object()实例化一个Object对象，但它并不放入缓存中。

在JVM中具有String常量池缓存的功能，所以如图 6-7 所示的结果为true。
这里写图片描述

图 6-7 Sting常量池缓存

同步synchronized（非this对象x）语句块具有一定的优点：如果在一个类中有很多个synchronized 方法，这时虽然能实现同步，但会受到阻塞，所以影响运行效率；但如果使用同步语句块非this对象，则synchronized （非this对象x）语句块中的程序与同步方法是异步的，不与其他锁this同步方法争抢this锁，则可以大大提高运行效率。
“synchronized （非this对象x）”格式的写法是将x对象本身作为“对象监视器”，这样就可以得出以下3个结论：

  1. 当多个线程同时执行synchronized (x){}同步语句块时呈同步效果。
  2. 当其他线程执行x对象中synchronized 同步方法时呈同步效果。
  3. 当其他线程执行x对象方法里面的synchronized （this）语句块时也呈同步效果。

注意：如果其他线程调用不加synchronized 关键字的方法时，还是异步调用。

验证第一个结论：当多个线程同时执行synchronized (x){}同步语句块时呈同步效果，示例如下

/*验证当多个线程同时执行synchronized (x){}同步语句块时呈同步效果
*/
public class Test {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        Object object = new Object();
        ThreadA a = new ThreadA(service, object);
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(service, object);
        b.setName("B");
        b.start();
    }
}

class ThreadA extends Thread {
    private Service service;
    private Object object;

    public ThreadA(Service service, Object object) {
        super();
        this.service = service;
        this.object = object;

    }

    @Override
    public void run() {
        super.run();
        service.testMethod1(object);
    }

}

class ThreadB extends Thread {
    private Service service;
    private Object object;

    public ThreadB(Service service, Object object) {
        super();
        this.service = service;
        this.object = object;

    }

    @Override
    public void run() {
        super.run();
        service.testMethod1(object);
    }

}

class Service {

    public void testMethod1(Object object) {
        synchronized (object) {
            try {
                System.out.println("testMethod1--getLock     time:" + System.currentTimeMillis() + "   run ThreadName:"
                        + Thread.currentThread().getName());
                Thread.sleep(2000);
                System.out.println("testMethod1--releaseLock time:" + System.currentTimeMillis() + "   run ThreadName:"
                        + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

运行结果如图 6-8 所示
这里写图片描述

图 6-8 同步调用

同步的原因是使用了同一个“对象监视器”，如果使用不同的“对象监视器”就会异步执行。
对上面的代码作以下更改：

public class Test {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        ThreadA a = new ThreadA(service, new Object());
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(service, new Object());
        b.setName("B");
        b.start();
    }
}

运行结果如图 6-9 所示
这里写图片描述

图 6-9 异步调用

验证第二个结论：当其他线程执行x对象中synchronized 同步方法时呈同步效果，示例如下

public class Test {

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        MyObject object = new MyObject();
        ThreadA a = new ThreadA(service, object);
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(service, object);
        b.setName("B");
        b.start();
    }
}

class ThreadA extends Thread {
    private Service service;
    private MyObject object;

    public ThreadA(Service service, MyObject object) {
        super();
        this.service = service;
        this.object = object;

    }

    @Override
    public void run() {
        super.run();
        service.testMethod1(object);
    }

}

class ThreadB extends Thread {
    private Service service;
    private MyObject object;

    public ThreadB(Service service, MyObject object) {
        super();
        this.service = service;
        this.object = object;

    }

    @Override
    public void run() {
        super.run();
        object.speedPrintString();
    }

}

class Service {

    public void testMethod1(MyObject object) {
        synchronized (object) {
            try {
                System.out.println("testMethod1--getLock     time:" + System.currentTimeMillis() + "   run ThreadName:"
                        + Thread.currentThread().getName());
                Thread.sleep(5000);
                System.out.println("testMethod1--releaseLock time:" + System.currentTimeMillis() + "   run ThreadName:"
                        + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class MyObject {
    public synchronized void speedPrintString() {
        System.out.println("speedPrintString--getLock     time:" + System.currentTimeMillis() + "   run ThreadName:"
                + Thread.currentThread().getName());
        System.out.println("-------------------");
        System.out.println("speedPrintString--releaseLock time:" + System.currentTimeMillis() + "   run ThreadName:"
                + Thread.currentThread().getName());
    }
}

运行结果如图 6-10 所示
这里写图片描述

图 6-10 同步效果

验证第三个结论：当其他线程执行x对象方法里面的synchronized （this）语句块时也呈同步效果，示例如下
对上面的代码作以下更改

class MyObject {
    public  void speedPrintString() {
        synchronized (this) {
            System.out.println("speedPrintString--getLock     time:" + System.currentTimeMillis() + "   run ThreadName:"
                    + Thread.currentThread().getName());
            System.out.println("-------------------");
            System.out.println("speedPrintString--releaseLock time:" + System.currentTimeMillis() + "   run ThreadName:"
                    + Thread.currentThread().getName());
        }

    }
}

运行结果如图 6-11 所示
这里写图片描述

图 6-11 也是同步效果

一叶丿清风
关注
专栏目录
Java多线程synchronized同步方法详解
08-24
`synchronized`关键字可以应用于方法或代码块，以实现线程同步。对于同步方法，锁对象是该方法所在类的实例。这意味着如果一个线程已经获取了某个对象的锁，并正在执行该对象的`synchronized`方法，其他试图访问...
同步与异步，如何解决线程安全问题—synchronized详解，对象锁与类锁，静态与非静态同步方法详解
方圆几里
07-16 1667
欢迎使用Markdown编辑器写博客 本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 同步与异步 原意 同步：是所有的操作都做完，才返回给用户结果（某个人做...
Java异步调用转同步的5种方式
weixin_42113716的博客
09-09 861
Java异步调用转同步的5种方式
java 总结几种线程异步转同步的方法
Vecrates
12-28 8913
今天在做app的时候，用到了一个异步执行的api，而我想要的是同步执行，查了一些资料，对几种情况下的线程同步做一下总结。 一、共享资源的同步: 当一个资源被多个线程访问会发生错误，只能允许一个线程访问时。 1.syschronized实现 使用syschonized关键字可对某个块或者方法进行限制访问，即当一个线程获得块或者方法的访问权后，其他线程将不能访问。 public cla
异步编程学习之路（二）-通过Synchronized实现线程安全的多线程
最新发布
2401_83621499的博客
04-14 1000
运行结果：70267正确结果应该是10万。其实volatile关键字只能够保证多线程之间的内存可见性，而不能保证多个线程之间的有序性。为什么synchronized能够保证线程安全而volatile不行呢？二、JMM内存模型Java 内存模型来屏蔽掉各种硬件和操作系统的内存差异，达到跨平台的内存访问效果。JLS(Java语言规范)定义了一个统一的内存管理模型JMM(Java Memory Model)
synchronized一半同步一半异步（菜鸟玩线程）
Zohar的博客
11-07 674
synchronized一半同步一半异步 论证 不在synchronized块中就是异步执行，在synchronized块中就是同步执行。 示例 自定义共享类 package com.chapter02.thread4; public class Task { public void doLongTimeTask() { for (int i = 0; i < 10...
Java 多线程与并发(4-26)-关键字- synchronized详解.pdf
07-21
"Java 多线程与并发(4-26)-关键字- synchronized详解" Java 多线程与并发中的 synchronized 关键字是实现同步块的互斥访问和线程的阻塞及唤醒等工作的重要工具。下面将对 synchronized 关键字进行详细分析。 ...
java-synchronized详解.doc
05-09
总结来说，`synchronized`是Java中实现线程同步的关键机制，确保了多线程环境下的数据一致性。理解它的用法和工作原理对于编写健壮的多线程程序至关重要。正确使用`synchronized`可以帮助开发者避免竞态条件和死锁等...
java线程同步操作实例详解
08-27
Java线程同步操作实例详解 Java线程同步操作是指在多线程编程中，为了避免线程之间的数据不一致和混乱，采取的一种机制，以确保线程安全。Java提供了多种方式来实现线程同步，包括synchronized关键字、Lock接口、...
Java线程之线程同步synchronized和volatile详解
08-28
Java线程之线程同步synchronized和volatile详解 Java线程同步是Java多线程编程中非常重要的一个方面，主要涉及到线程安全、可见性和有序性三个方面。Java提供了多种同步机制来解决线程安全问题，包括synchronized和...
java 同步锁 异步锁_十八、线程同步、线程异步和锁机制synchronized
weixin_30313365的博客
02-19 2902
1、线程模型1)线程异步：多个线程之间独立执行，谁也不用等谁线程同步：一个线程必需等另外一个线程执行完毕之后才能执行备注：为了数据的安全，尽管应用程序的使用率低，但是为了保证数据是安全的，必须加入线程同步机制，线程同步机制使程序变成了(等同)单线程2)什么条件下要使用线程同步？第一: 必须是多线程环境第二: 多线程环境共享同一个数据第三: 共享的数据涉及到修改操作3)同步方法和同步代码块的区别:在...
Synchronize对象锁异步
天高任鸟飞
08-23 341
对象锁异步 A线程，先持有对象的锁 b线程，可以以异步的方式，调用对象中的非synchronize修饰的方法 package com.bjsxt.base.sync003; /** * 对象锁的同步和异步问题 * */ public class MyObject { public synchronized void method1(){ try { ...
java线程、线程池，类、对象锁 java线程通信，线程的状态 wait/notify
emmmsuperdan的博客
03-23 5889
同步：发送一个指令，需要等待返回结果，才能发出下一个指令，需要等待； 异步：发送一个指令，不需要等待，即可直接发出下一个指令； 一般情况下，都采用异步，效率更高；但是比如说银行系统，必须采用同步，这样才能保证数据的共享和安全性； synchronize关键字： 每个 synchronized 方法都必须获得调用该方法的类实例的锁（或者类锁）方能执行，否则所属线程阻塞；直到synchr...
同步（synchronized）和异步（asynchronized）
不爱吃香菜的帅小伙
11-18 2102
/** * 多线程之对象同步锁和异步锁Demo * * @author ietree */ public class SynAndAsynDemo { public static void main(String[] args) { final SynAndAsynDemo mo = new SynAndAsynDemo(); Threa...
synchronized对象锁的同步和异步问题
木村的博客
11-03 6862
先上代码:public class MyObject { public synchronized void method1(){ try { System.out.println(Thread.currentThread().getName()); Thread.sleep(4000); } catch (Int
java Synchronized 异步互斥详解
knight
07-08 6778
在编写一个类时，如果该类中的代码可能运行于多线程环境下，那么就要考虑同步的问题。在Java中内置了语言级的同步原语－－synchronized，这也大大简化了Java中多线程同步的使用。我们首先编写一个非常简单的多线程的程序，是模拟银行中的多个线程同时对同一个储蓄账户进行存款、取款操作的。         在程序中我们使用了一个简化版本的Account类，代表了一个银行账户的信息。在主程序中我们
Java多线程（三）——synchronized
pandamig的博客
01-31 201
Java多线程（三） 本章主要讨论synchronized。 1.概述 “非线程安全”问题会在多个线程对同一个对象中的实例变量进行并发访问时发生，产生的后果就是“脏读”，也就是取到的数据其实是被更改过的。而“线程安全”就是以获得的实例变量的值是经过同步处理的，不会出现脏读的现象。 synchronzied用来保证线程安全。 2.synchronized的用法 synchronized的用法共有如下四种： （1）synchronized同步方法 （2）synchronized(this)同步代码块 （3）s
了解java中的synchronized关键字
weixin_43225491的博客
10-30 333
synchronized是java的一个关键字,用于java多线程中的同步. 1.synchronized可修饰方法上,被修饰的方法为同步方法,多个线程访问同一对象的同步方法是同步执行的,即排队执行,哪个线程先执行该方法就持有该方法的所属对象的锁Lock,其他线程就处于等待状态。 2.synchronized可修饰于代码块中,被修饰的代码块为同步代码块,多线程访问时,一个线程访问object的synchronized同步代码块,其他线程仍然可以访问该object对象中非synchronized（this）代
TimerTask类和Timer类的cancel()方法详解
热门推荐
一叶丿清风的博客
08-11 3万+
无论是TimerTask类还是Timer类，其cancel()方法都是为了清除任务队列中的任务。虽然都是清除任务队列中的任务，却有一些不同：TimerTask类中的cancel()方法侧重的是将自身从任务队列中清除，其他任务不受影响，而Timer类中的cancel()方法则是将任务队列中全部的任务清空。下面以具体示例进行演示。 TimerTask类中的cancel()方法测试：import jav
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值