你所知道的synchronized关键字

最新推荐文章于 2022-10-14 14:35:04 发布

new_repo

最新推荐文章于 2022-10-14 14:35:04 发布

阅读量191

点赞数

本文链接：https://blog.csdn.net/Mabanana/article/details/107110847

版权

原理

在Java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在的。
当我们调用某个对象的synchronized方法的时候，就获取到了该对象的同步锁。如：synchronized(e)就获取到了"e这个对象"的同步锁。
不同线程对同步锁的访问是互斥的，在某个时间点，对象的同步锁只能被一个线程获取到。通过同步锁，我们可以在多线程中实现对“对象/方法”的互斥访问。比如：有两个访问同一个同步锁的线程A和线程B，在某一时刻，线程A获取到这个同步锁并执行一些操作；而此时，线程B也企图获取同步锁，那么线程B就会获取失败，进入等待状态，直到线程A释放了同步锁资源之后线程B才能获取到同步锁进行运行。

规则

当一个线程访问某对象的synchronized方法或者synchronized代码块时，其他线程对该对象的synchronized方法或者synchronized代码块的访问将被阻塞
当一个线程访问某对象的synchronized方法或者代码块时，其他线程依然可以访问该对象的非同步代码块
当一个线程访问某对象的synchronized方法或者代码块时，其他线程对该对象的其他synchronized方法或者synchronized代码块访问将被阻塞

如：

//1、当一个线程访问某对象的synchronized方法或者synchronized代码块时，其他线程对该对象的synchronized方法或者synchronized代码块的访问将被阻塞

class MyRunnable implements Runnable{
	@Override
	public void run(){
		synchronized(this){
			try{
				for(int i=0;i<5;i++){
					Thread.sleep(100);//睡眠100ms
					System.out.println(Thread.currentThread.getName()+"loop"+i);
				}
			}catch(InterruptedException ie){
			}
		}
	}
};

public class Demo_01{
	public static void main(String[] args){
		Runnable demo=new MyRunnable();//新建Runnable对象
		
		Thread t1=new Thread(demo,"t1");
		Thread t2=new Thread(Demo,"t2");
		t1.start();
		t2.start();
	}
}

执行结果：

t1 loop 0
t1 loop 1
t1 loop 2
t1 loop 3
t1 loop 4
t2 loop 0
t2 loop 1
t2 loop 2
t2 loop 3
t2 loop 4

结果说明：
run方法中存在synchronized代码块，而且t1和t2都时基于demo的runnable对象创建的线程。线程t1和t2共享demo的同步锁，当一个线程运行时另一个线程处于阻塞状态，无法执行。

class MyThread extends Thread{
	public MyThread(String name){
		super(name);
	}
	
	@Override
	public void run(){
		synchronized(this){
			try{
				for(int i=0;i<5;i++){
					Thread.sleep(100);//休眠100ms
					System.out.println(Thread.currentThread.getName()+"loop"+i);
				}
			}catch(InterruptedException ie){
			}
		}
	}
};

public class Demo_02{
	public static void main(String[] args){
		Thread t1=new MyThread("t1");
		Thread t2=new MyThread("t2");
		t1.start();
		t2.start();
	}
}

执行结果：

t1 loop 0
t2 loop 0
t1 loop 1
t2 loop 1
t1 loop 2
t2 loop 2
t1 loop 3
t2 loop 3
t1 loop 4
t2 loop 4

结果分析：
synchronized(this)中的this代表的是MyThread对象，而t1和t2是两个不同的MyThread对象，因此t1和t2在执行synchronized(this)时，获取的是不同对象的同步锁。所以会交叉进行执行…

//2、当一个线程访问某对象的synchronized方法或者synchronized代码块时，其他线程仍然可以访问该对象的非同步代码块

class Count {

    // 含有synchronized同步块的方法
    public void synMethod() {
        synchronized(this) {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100); // 休眠100ms
                    System.out.println(Thread.currentThread().getName() + " synMethod loop " + i);
                }
            } catch (InterruptedException ie) {
            }
        }
    }

    // 非同步的方法
    public void nonSynMethod() {
        try {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);
            }
        } catch (InterruptedException ie) {
        }
    }
}

public class Demo2 {

    public static void main(String[] args) {
        final Count count = new Count();
        // 新建t1, t1会调用“count对象”的synMethod()方法
        Thread t1 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        count.synMethod();
                    }
                }, "t1");

        // 新建t2, t2会调用“count对象”的nonSynMethod()方法
        Thread t2 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        count.nonSynMethod();
                    }
                }, "t2");


        t1.start();  // 启动t1
        t2.start();  // 启动t2
    }
}

执行结果：

t1 synMethod loop 0
t2 nonSynMethod loop 0
t1 synMethod loop 1
t2 nonSynMethod loop 1
t1 synMethod loop 2
t2 nonSynMethod loop 2
t1 synMethod loop 3
t2 nonSynMethod loop 3
t1 synMethod loop 4
t2 nonSynMethod loop 4

结果分析：
因为t2线程中执行的是count对象的非同步方法，所以虽然t1也在占用count的同步锁，但是仍然可以执行，没有造成阻塞

//当一个线程访问某个对象的synchronized方法或者synchronized代码块时，其他线程对该对象的其他synchronized方法或者synchronized代码块的访问将被阻塞

class Count {

    // 含有synchronized同步块的方法
    public void synMethod() {
        synchronized(this) {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100); // 休眠100ms
                    System.out.println(Thread.currentThread().getName() + " synMethod loop " + i);
                }
            } catch (InterruptedException ie) {
            }
        }
    }

    // 也包含synchronized同步块的方法
    public void nonSynMethod() {
        synchronized(this) {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);
                }
            } catch (InterruptedException ie) {
            }
        }
    }
}

public class Demo3 {

    public static void main(String[] args) {
        final Count count = new Count();
        // 新建t1, t1会调用“count对象”的synMethod()方法
        Thread t1 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        count.synMethod();
                    }
                }, "t1");

        // 新建t2, t2会调用“count对象”的nonSynMethod()方法
        Thread t2 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        count.nonSynMethod();
                    }
                }, "t2");


        t1.start();  // 启动t1
        t2.start();  // 启动t2
    }
}

执行结果：

t1 synMethod loop 0
t1 synMethod loop 1
t1 synMethod loop 2
t1 synMethod loop 3
t1 synMethod loop 4
t2 nonSynMethod loop 0
t2 nonSynMethod loop 1
t2 nonSynMethod loop 2
t2 nonSynMethod loop 3
t2 nonSynMethod loop 4

因为t1线程和t2线程都需要使用count对象同步锁，所以在t1运行时t2会被阻塞，等t1执行结束释放count对象的同步锁之后，t2才能获取count对象同步锁执行。

synchronized方法和代码块有什么区别吗？

答案是肯定的，字面意思–>synchronized方法是用synchronized修饰方法，synchronized代码块使用synchronized修饰代码块。

synchronized方法

public synchronized void fool(){
	System.out.println("syschronized method");
}

synchronized代码块

public void fool2(){
	synchronized (this){
		System.out.println("syschronized method");
	}
}

synchronized代码块中的this是指当前对象。也可以将this替换成其他对象，例如将this替换成obj，则foo2()在执行synchronized(obj)时就获取的是obj的同步锁。

但是更加提倡使用syschronized代码块，因为代码块可以更精确的控制冲突限制访问区域，有着更高的执行效率

实例锁和全局锁又是什么？

学过Java编程的大家应该都知道实例的概念，更多的是加上对象二字–>实例对象，而实例锁就是加在实例对象上的锁；而全局锁则是针对的整个类，无论实例多少个对象，线程都共享该锁，当然如果实例对象的类是实例的，那么实例锁也就具有了全局锁的概念
全局锁通常对应的就是static synchronized
如：

pulbic class Something {
    public synchronized void isSyncA(){}
    public synchronized void isSyncB(){}
    public static synchronized void cSyncA(){}
    public static synchronized void cSyncB(){}
}

一定一定要注意synchronized关键字的三大规则，在实例锁和全局锁中也是存在这个问题。

new_repo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
你所知道的synchronized关键字

原理在Java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在的。当我们调用某个对象的synchronized方法的时候，就获取到了该对象的同步锁。如：synchronized(e)就获取到了"e这个对象"的同步锁。不同线程对同步锁的访问是互斥的，在某个时间点，对象的同步锁只能被一个线程获取到。通过同步锁，我们可以在多线程中实现对“对象/方法”的互斥访问。比如：有两个访问同一个同步锁的线程A和线程B，在某一时刻，线程A获取到这个同步锁并执行一些操作；而此时，线程B也企图获取同步锁
复制链接

扫一扫