A-A+

Java-Synchronized用法(4)

2019年03月03日 技术 暂无评论 阅读 171 次

Synchronized主要有以下几种用法:

1. 加在方法上:这里包括加在实例方法上、加在静态方法上。

2. 方法块:这里包括锁定this、锁定Class、锁定实例对象、锁定静态对象。

今天主要通过例子演示一下第一个用法:加在实例方法上和加在静态方法上时,不同的函数方法之间的相互影响。

首先是加在实例方法上

测试代码如下:

import org.junit.Test;

import java.util.Scanner;

public class ThreadTest {

    public synchronized void printStatic1(String input) {
        System.out.println(input + System.currentTimeMillis());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("3秒后的" + input + System.currentTimeMillis());
    }

    public synchronized void printStatic2(String input) {
        System.out.println(input + System.currentTimeMillis());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("3秒后的" + input + System.currentTimeMillis());
    }

    private void waitToQuite() {
        new Scanner(System.in).next();
    }

    //region 测试方法

    /**
    * 锁定同一个类中不同的实例方法,相同对象调用时需要等待
    */

    @Test
    public void test1() {

        final ThreadTest test1 = new ThreadTest();

        new Thread(() -> {
            System.out.println("第一个线程已启动");
            test1.printStatic1("我是第一个线程");
        }).start();

        new Thread(() -> {
            System.out.println("第二个线程已启动");
            test1.printStatic2("我是第二个线程");
        }).start();

        waitToQuite();
    }

    /**
     * 锁定同一个类中不同的实例方法,不同对象调用时不用等待
     */

    @Test
    public void test2() {

        final ThreadTest test1 = new ThreadTest();
        final ThreadTest test2 = new ThreadTest();

        new Thread(() -> {
            System.out.println("第一个线程已启动");
            test1.printStatic1("我是第一个线程");
        }).start();

        new Thread(() -> {
            System.out.println("第二个线程已启动");
            test2.printStatic2("我是第二个线程");
        }).start();

        waitToQuite();
    }

    //endregion
}

测试结果如下:


锁定同一个类中不同的实例方法,相同对象调用时需要等待

锁定同一个类中不同的实例方法,不同对象调用时不用等待

其次是加在静态方法上

测试代码如下:

import org.junit.Test;

import java.util.Scanner;

public class ThreadTest {

    public synchronized static void printStatic1(String input) {
        System.out.println(input + System.currentTimeMillis());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("3秒后的" + input + System.currentTimeMillis());
    }

    public synchronized static void printStatic2(String input) {
        System.out.println(input + System.currentTimeMillis());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("3秒后的" + input + System.currentTimeMillis());
    }

    public void callPrintStatic1(String input) {
        printStatic1(input);
    }

    public void callPrintStatic2(String input) {
        printStatic2(input);
    }

    private void waitToQuite() {
        new Scanner(System.in).next();
    }

    //region 测试方法

    /**
    * 锁定同一个类中不同的静态方法,相同对象调用时等待
    */

    @Test
    public void test1() {

        final ThreadTest test1 = new ThreadTest();

        new Thread(() -> {
            System.out.println("第一个线程已启动");
            test1.callPrintStatic1("我是第一个线程");
        }).start();

        new Thread(() -> {
            System.out.println("第二个线程已启动");
            test1.callPrintStatic2("我是第二个线程");
        }).start();

        waitToQuite();
    }

    /**
     * 锁定同一个类中不同的静态方法,不同对象调用时等待
     */

    @Test
    public void test2() {

        final ThreadTest test1 = new ThreadTest();
        final ThreadTest test2 = new ThreadTest();

        new Thread(() -> {
            System.out.println("第一个线程已启动");
            test1.callPrintStatic1("我是第一个线程");
        }).start();

        new Thread(() -> {
            System.out.println("第二个线程已启动");
            test2.callPrintStatic2("我是第二个线程");
        }).start();

        waitToQuite();
    }

    //endregion
}

测试结果如下:


锁定同一个类中不同的静态方法,相同对象调用时等待

锁定同一个类中不同的静态方法,不同对象调用时等待
觉的不错?可以关注我的公众号↑↑↑
哼哼的泰迪熊

给我留言

Copyright © 字痕随行 保留所有权利.   Theme  Ality 京ICP备14039894号

用户登录

分享到: