java synchronized测试程序

最新推荐文章于 2023-12-30 18:28:47 发布
最新推荐文章于 2023-12-30 18:28:47 发布
阅读量622 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acxingyun/article/details/72160605
版权

看了些网上相关的文章，感觉有些结果不对，于是自己跑了一遍这些demo并附上每段程序结果和一些心得。

非线程安全的代码

public class Run {

    public static void main(String[] args) {

        HasSelfPrivateNum numRef = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef);
        ThreadB bthread = new ThreadB(numRef);

        athread.start();
        bthread.start();

    }
}

class HasSelfPrivateNum {

    private int num = 0;

    public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}


class ThreadA extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }

}



class ThreadB extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }

}

结果：

a set over!
b set over!
b num=200
a num=200

A线程给num传100后进入sleep状态；B线程又传200，A线程恢复后打印出来的结果就是200。
给addI加上synchroized：

public class Run {

    public static void main(String[] args) {

        HasSelfPrivateNum numRef = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef);
        ThreadB bthread = new ThreadB(numRef);

        athread.start();
        bthread.start();

    }
}

class HasSelfPrivateNum {

    private int num = 0;

    synchronized public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

class ThreadA extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }

}

class ThreadB extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }

}

结果：

a set over!
a num=100
b set over!
b num=200

加上锁不会出现多个线程同时进入一个方法块的情况，只有当一个代码块执行完后才执行另一个线程。

多线程多对象：

public class Run {

    public static void main(String[] args) {

        HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
        HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef1);
        ThreadB bthread = new ThreadB(numRef2);

        athread.start();
        bthread.start();

    }
}

class HasSelfPrivateNum {

    private int num = 0;

    synchronized public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}


class ThreadA extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }

}



class ThreadB extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }

}

结果：

b set over!
a set over!
b num=200
a num=100

多对象因为相互之间是独立的，不存在要获得对象锁的问题，去掉synchronized关键字结果也是一样的。多对象也不需要保证线程安全了。

同步块synchronized (this)

public class Run {

    public static void main(String[] args) {
        ObjectService service = new ObjectService();

        ThreadA a = new ThreadA(service);
        a.setName("a");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("b");
        b.start();
    }
}

class ObjectService {

    public void serviceMethod() {
        try {
            synchronized (this) {
                System.out.println("begin time=" + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end    end=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


class ThreadA extends Thread {

    private ObjectService service;

    public ThreadA(ObjectService service) {
        super();
        this.service = service;
    }

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

}


class ThreadB extends Thread {
    private ObjectService service;

    public ThreadB(ObjectService service) {
        super();
        this.service = service;
    }

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

结果

begin time=1494832547802
end    end=1494832549803
begin time=1494832549803
end    end=1494832551803

synchronized (this)的this是ObjectService的一个对象。
当一个线程进入synchronized(this){}中，对象的其它包含synchronized的代码是被当前线程独占的。
关于synchronized (this)最后还会专门举例说明。

非this对象

public class Run {

    public static void main(String[] args) {

        Service service = new Service("xiaobaoge");
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
    }
}

class Service {
    String anyString = new String();
    public Service(String anyString){
        this.anyString = anyString;
        System.out.println("anyString: " + anyString);
    }

    public void setUsernamePassword(String username, String password) {
        try {
            synchronized (anyString) {
                System.out.println("thread name: " + Thread.currentThread().getName()
                        + " go to sync at: " + System.currentTimeMillis());
                Thread.sleep(3000);
                System.out.println("thread name: " + Thread.currentThread().getName()
                        + " go out of sync at: " + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.setUsernamePassword("a", "aa");
    }
}


class ThreadB extends Thread {

    private Service service;
    public ThreadB(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.setUsernamePassword("b", "bb");
    }
}

结果：

anyString: xiaobaoge
thread name: A go to sync at: 1494833882106
thread name: A go out of sync at: 1494833885106
thread name: B go to sync at: 1494833885106
thread name: B go out of sync at: 1494833888106

能保证同步块里的代码是线程安全的。

静态synchronized同步方法

记住一句话：static方法是属于类的，用synchronized修饰static方法就是对类上锁。

public class Run {

    public static void main(String[] args) {

        ThreadA a = new ThreadA();
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB();
        b.setName("B");
        b.start();

    }

}

class Service {

    synchronized public static void printA() {
        try {
            System.out.println("thread: " + Thread.currentThread().getName()
                    + " go to printA at " + System.currentTimeMillis());
            Thread.sleep(3000);
            System.out.println("thread: " + Thread.currentThread().getName()
                    + " go out printA at " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB() {
        System.out.println("thread: " + Thread.currentThread().getName() + " go to printB at "
                + System.currentTimeMillis());
        System.out.println("thread: " + Thread.currentThread().getName() + " go out printB at "
                + System.currentTimeMillis());
    }

}


class ThreadA extends Thread {
    @Override
    public void run() {
        Service.printA();
    }

}


class ThreadB extends Thread {
    @Override
    public void run() {
        Service.printB();
    }
}

结果：

thread: A go to printA at 1494834629062
thread: A go out printA at 1494834632062
thread: B go to printB at 1494834632062
thread: B go out printB at 1494834632062

printA 和printB 虽然是不同的方法，但因为static修饰的方法和变量都是属于类的，对static方法加锁相当于对类加锁，因此类是线程安全的。

synchronized (class)

类锁：

public class Run {

    public static void main(String[] args) {

        ThreadA a = new ThreadA();
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB();
        b.setName("B");
        b.start();
    }
}

class Service {

    public static void printA() {
        synchronized (Service.class) {
            try {
                System.out.println("thread: " + Thread.currentThread().getName()
                        + " go to printA at: " + System.currentTimeMillis());
                Thread.sleep(3000);
                System.out.println("thread: " + Thread.currentThread().getName()
                        + " go out printA at: " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void printB() {
        synchronized (Service.class) {
            System.out.println("thread: " + Thread.currentThread().getName()
                    + " go to printB at: " + System.currentTimeMillis());
            System.out.println("thread: " + Thread.currentThread().getName()
                    + " go out printB at: " + System.currentTimeMillis());
        }
    }
}


class ThreadA extends Thread {
    @Override
    public void run() {
        Service.printA();
    }
}


class ThreadB extends Thread {
    @Override
    public void run() {
        Service.printB();
    }
}

结果：

thread: A go to printA at: 1494835990458
thread: A go out printA at: 1494835993459
thread: B go to printB at: 1494835993459
thread: B go out printB at: 1494835993459

执行printA时对类上锁，类是线程安全的。

补充关于synchronized(this)的例子

当一个线程访问类中synchronized(this)代码块时，其它没有带synchronized的代码块不是线程独占的：

public class Thread2 {
    public void m4t1() {
        synchronized (this) {
            int i = 5;
            while (i-- > 0) {
                System.out
                        .println(Thread.currentThread().getName() + " : " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException ie) {
                }
            }
        }
    }

    public void m4t2() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException ie) {
            }
        }
    }

    public static void main(String[] args) {
        final Thread2 myt2 = new Thread2();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                myt2.m4t1();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                myt2.m4t2();
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}

结果：

t1 : 4
t2 : 4
t2 : 3
t1 : 3
t2 : 2
t1 : 2
t2 : 1
t1 : 1
t2 : 0
t1 : 0

如果一个线程正在访问synchronized(this)代码块，则带synchronized的其它代码块都是被当前线程独占的：

public class Thread2 {
    public void m4t1() {
        synchronized (this) {
            int i = 5;
            while (i-- > 0) {
                System.out
                        .println(Thread.currentThread().getName() + " : " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException ie) {
                }
            }
        }
    }

    public void m4t2() {
        synchronized (this){
            int i = 5;
            while (i-- > 0) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException ie) {
                }
            }
        }
    }

    public static void main(String[] args) {
        final Thread2 myt2 = new Thread2();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                myt2.m4t1();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                myt2.m4t2();
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}

结果：

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

带synchronized关键字的部分都是同步代码块，当一个线程访问synchronized(this)时相当于拿到了这个对象的对象锁，对同步代码块的访问需要保证当前线程有该对象的对象锁。

有点像铁索连环，一个受影响全部受影响，解锁一个其它的才能访问。

acxingyun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java并发编程test之synchronized测试
weixin_33967071的博客
01-12 260
2019独角兽企业重金招聘Python工程师标准>>> ...
synchronized关键字-线程同步总结+测试用例
天道酬勤
03-14 187
synchronized关键字-线程同步总结+测试用例
Java | synchronized 不同情况下的对象头测试
双鬼带单
11-27 618
在 Oracle JDK 8 上测试 synchronized 在不同情况下对象头的变化
Java同步synchronized
joedan0104的专栏
06-25 273
一. synchronized是什么？ synchronized是Java的一个关键字，synchronized依赖于JVM具体实现。 synchronized的作用 synchronized也称为同步锁。synchronized是一种独占锁。 synchronized的两大功能： 内存可见性 操作原子性 什么是内存可见性？ 可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。 可参考《Java内存分级和指令重排序》。volatile也可实现内存
java学习：对synchronized的测试
weixin_30652491的博客
09-29 83
平时对synchronized这个关键字没有太在意，对它的认识停留在粗略翻了一下百度百科的状态，百度百科对它的解释是： “Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以...
Java教学测试程序
06-30
Java教学测试程序是一系列用于教学目的的源代码示例，旨在帮助初学者更好地理解和掌握Java编程语言的基础概念和核心特性。这些小程序涵盖了Java语言的各个方面，包括但不限于变量、数据类型、控制流、类与对象、继承...
java多线程中测试同步的小程序
12-22
这是我做的一个很简单的多线程同步程序，目的是为了测试多线程编程下如何使用同步（synchronized）防止产生竞争共享资源的错误状态，从中得到的心得是：一定要将你所共享的变量封装在一个类中，将所有有关该变量的...
Java基础测试题.pdf
10-03
5. **Java程序运行顺序**：Java程序的运行环境从底层到顶层依次是硬件、操作系统、JRE/JVM（Java运行时环境/Java虚拟机）和Java程序。 6. **接口关键字**：在接口中，变量和方法默认是`public static final`的，...
在Java内存模型中测试并发程序代码
09-03
在Java内存模型中，测试并发程序代码是一项挑战性的工作，因为并发执行可能导致数据竞争、死锁、活锁等问题。Java内存模型（JMM）定义了线程如何共享和访问内存，以及它们之间的通信规则。本篇文章主要关注如何利用...
JAVA第九、十、十一章测试1
08-03
5. **临界区与同步**：在Java中，临界区通常是指需要互斥访问的代码段，可以使用`synchronized`关键字来标识，确保同一时间只有一个线程能执行这部分代码。 6. **线程活动的实现**：线程的活动主要由`run()`方法...
测试synchronized的底层实现
weixin_39265427的博客
05-09 468
测试synchronize的底层实现1、synchronized的三种应用方式1.1. 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁修饰实例方法案例反编译结果分析(ACC_SYNCHRONIZED)1.2. 静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁修饰静态方法案例反编译结果分析(ACC_SYNCHRONIZED)1.3. 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。修饰代码块案例反编译结果分析(monitorenter\mon
测试Synchronized和Lock的性能区别
小奶牛的博客
04-27 151
定义一个int变量index，分别使用ReentrantLock 和 synchronized 进行1亿次新增的测试，观察对应的消耗时间。Synchronized锁原理：无锁=>偏向锁=>轻量级锁=>重量级锁。Lock锁原理：底层是JDK的AQS，使用的CAS加等待队列的方式加锁。Lock在竞争状态下性能表现。测试JDK版本：JDK8。
Synchronized理解与测试
Mying的博客
07-03 397
Synchronized简单测试 1.synchronized关键子说明 对于操作系统进程来说，资源分配是很重要的一个问题，如果操作不当会造成多个进程抢占同一个资源，进而造成死锁，无限等待。线程同样无法避免这个问题，对于资源的控制与分配，Java提供了很多方法，Synchronzied是同步入门。 （注：避免进程死锁的四个方法： 互斥条件：每个资源同时只能有一个进程访问。 请求与保持：一个进程因...
Java----synchronized的小测试
JAVAweb学习
02-22 327
方式一：方法内部修饰  public class ThreadTest { public static List forLey = new ArrayList(); public void doFun() { try { Thread.currentThread().sleep(600); } catch (Exception e) { e.printStackTra
synchronized效用的测试
最新发布
m0_70869229的博客
12-30 411
synchronized关键字可以将对象或者类进行锁定，不让其他线程调用，使用代码进行测试。
JAVA中关于Synchronized和Volatile的测试
weixin_34112030的博客
06-18 68
JAVA中Volatile关键字，在编写多线程和高并发的程序的时候,尤为重要.其中Volatile涉及到CPU中的Cache Line 和内存屏障, 这里就不去深究了.详细资料可以去看MESI协议.真实项目中, 最近在优化和重构时候, 发现了一些代码问题, 重构代码之后, 把知识点以后整理了出来.下面例子里, 是一段生产环境代码扣出来的逻辑, 功能上看上去并没有太大的问题. ...
java之synchronized代码测试
shareinfo2018
12-28 299
public static synchronized void synPrint(String str){ for( int i=0; i<10; i++){ try { System.out.print(str+" =>"+i+"\n"); Thread.sleep(10); } catch (InterruptedException e) { e.pri
synchronized测试
jinghongtianxia的博客
11-12 272
public class BeSynchronized { private BeSynchronized() { } public static BeSynchronized getInstance() { return getIns.INSTANCE.returnInstance(); } public void runBeS...
java面试,经典的八股文208题测试
09-12
本文是一个关于Java面试的经典题目测试，一共包含19个模块：Java基础、容器、多线程、反射、对象拷贝、Java Web、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值