Android中synchronized加锁控制主线程和子线程(同步执行、顺序执行)

参考网址:https://blog.csdn.net/night_dragon/article/details/54409473

https://blog.csdn.net/huanyuminhao/article/details/51960256

1.顺序执行(先让子线程执行完毕,再继续执行主线程)

private Object obj = new Object();
private void test(){
    new Thread(){
        @Override
        public void run() {
            super.run();
            try{
                for (int a=0;a<10;a++){
                    System.out.println("输出A:"+a);
                }
            }catch (Exception e){

            }finally {
                synchronized (obj) {
                    obj.notify();
                }
            }
        }
    }.start();
    try {
        synchronized (obj) {
            obj.wait();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    for (int a=0;a<10;a++){
        System.out.println("输出B:"+a);
    }
}

打印结果

System.out: 输出A:0
System.out: 输出A:1
System.out: 输出A:2
System.out: 输出A:3
System.out: 输出A:4
System.out: 输出A:5
System.out: 输出A:6
System.out: 输出A:7
System.out: 输出A:8
System.out: 输出A:9
System.out: 输出B:0
System.out: 输出B:1
System.out: 输出B:2
System.out: 输出B:3
System.out: 输出B:4
System.out: 输出B:5
System.out: 输出B:6
System.out: 输出B:7
System.out: 输出B:8
System.out: 输出B:9

2.同步执行(子线程开始的时候,主线程正常运行)

private Object obj = new Object();
private void test(){
    new Thread(){
        @Override
        public void run() {
            super.run();
            try{
                for (int a=0;a<10;a++){
                    System.out.println("输出A:"+a);
                }
            }catch (Exception e){

            }finally {
                //synchronized (obj) {
                //    obj.notify();
                //}
            }
        }
    }.start();
    //try {
    //    synchronized (obj) {
            obj.wait();
    //    }
    //} catch (InterruptedException e) {
    //    e.printStackTrace();
    //}
    for (int a=0;a<10;a++){
        System.out.println("输出B:"+a);
    }
}

打印结果

System.out: 输出B:0
System.out: 输出B:1
System.out: 输出B:2
System.out: 输出B:3
System.out: 输出B:4
System.out: 输出B:5
System.out: 输出A:0
System.out: 输出B:6
System.out: 输出A:1
System.out: 输出B:7
System.out: 输出A:2
System.out: 输出B:8
System.out: 输出A:3
System.out: 输出B:9
System.out: 输出A:4
System.out: 输出A:5
System.out: 输出A:6
System.out: 输出A:7
System.out: 输出A:8
System.out: 输出A:9

说明:给obj对象加锁后执行顺序:子线程开始---同时向下执行遇到了加锁的obj.wait(),主线程在这里释放锁并休眠等待,当子线程运行完之后(先进入try,执行完后,进入到finally,唤醒了对象锁),代码继续向下执行

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在Java线程和子线程可以通过共享变量的方式来共享数据。共享变量通常是在线程声明的,而子线程可以通过引用这些变量来访问它们。 Java提供了一些机制来确保线程之间的同步和一致性,以避免并发问题。其最常用的是synchronized关键字和volatile关键字。 synchronized关键字可以确保在同一时间只有一个线程能够访问共享变量,从而避免多个线程同时修改同一个变量的值。在线程声明一个共享变量时,可以使用synchronized关键字来声明它为同步变量。 volatile关键字可以确保共享变量的可见性。它告诉编译器和JVM,该变量可能被另一个线程修改,因此需要确保每个线程都能看到最新的值。在线程声明一个共享变量时,可以使用volatile关键字来声明它为可见变量。 下面是一个简单的示例,演示如何在线程和子线程之间共享变量的值: ``` public class Main { private static volatile int count = 0; public static void main(String[] args) { Thread t = new Thread(new Runnable() { public void run() { count = 1; } }); t.start(); while (count == 0) { // 等待子线程修改count的值 } System.out.println("Count is: " + count); } } ``` 在这个例子,我们声明了一个静态的volatile变量count,用于在线程和子线程之间共享数据。在子线程,我们修改了count的值为1。在线程,我们使用一个while循环来等待子线程修改count的值。一旦count的值不再为0,线程输出count的值。 需要注意的是,共享变量的同步和可见性是非常重要的,否则可能导致数据不一致、死锁等问题。因此,在编写多线程程序时,一定要注意线程之间的同步和一致性。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值