Synchronized的使用方法

最新推荐文章于 2024-03-03 21:02:09 发布
最新推荐文章于 2024-03-03 21:02:09 发布
阅读量196 收藏 1
点赞数
分类专栏： Synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2231476020/article/details/100566266
版权
一、同步代码块

用synchronized把要出现线程安全问题的代码包起来，每次只能有一个线程执行

public class TestWindow1 {
	public static void main(String[] args) {
		Window1 w = new Window1();

		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);

		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}
class Window1 implements Runnable {
	int ticket = 100; // 共享数据
	public void run() {
		while (true) {
			synchronized (this) {
				if (ticket > 0) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "售票，票号为：" + ticket--);
				} else {
				    break;
                }
			}
		}
	}
}

上面代码中synchronized使用的锁为当前对象，即创建的Window1的实例，当然也可以使用其他的类实例

public class TestWindow2 {
	public static void main(String[] args) {
		Window2 w1 = new Window2();
		Window2 w2 = new Window2();
		Window2 w3 = new Window2();

		w1.setName("窗口1");
		w2.setName("窗口2");
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}
class Window2 extends Thread {
	static int ticket = 100;
	static Object obj = new Object();

	public void run() {
		while (true) {
			// synchronized (this) {//在本问题中，this表示：w1,w2,w3
			synchronized (obj) {
				if (ticket > 0) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "售票，票号为：" + ticket--);
				} else {
                    break;
                }
			}
		}
	}
}

上面的代码中，创建多线程的方式与第一种不同，这里是继承Thread 类的方式，因此在创建三个线程的时候，创建了三个Window2的实例对象，所以再使用this作为锁的时候，this为三个对象本身，所以三个线程使用的并不是同一把锁，所以并不能达到线程同步的目的，这里要使用其他的类对象来充当锁

二、同步方法
public class SynchronizedTest1 {
    public synchronized void methodA() {
        try {
            for (int i = 0; i < 3; i++) {
                System.out.println("methodA-" + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB() {
        synchronized (this) {
            try {
                for (int i = 0; i < 3; i++) {
                    System.out.println("methodB-" + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void methodC() {
        Object obj = new Object();
        synchronized (obj) {
            try {
                for (int i = 0; i < 3; i++) {
                    System.out.println("methodC-" + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedTest1 test1 = new SynchronizedTest1();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                test1.methodA();
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                test1.methodB();
            }
        });
        thread2.start();

        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                test1.methodC();
            }
        });
        thread3.start();

    }
}
执行结果：
methodA-0
methodC-0
methodA-1
methodC-1
methodA-2
methodC-2
methodB-0
methodB-1
methodB-2

在非静态方法上加synchronized修饰，同样能达到同步的目的，thread1 和 thread2 两个线程同时执行同一个对象被synchronized修饰的方法时，只能有一个线程执行，另一个线程处于等待，此时锁为this，即当前对象。基于上面的分析，下面的使用方式将不会达到同步的效果

class Window2 extends Thread {
	static int ticket = 100;//共享数据
	
	public void run() {
		while (true) {
			show();
		}
	}
	public synchronized void show() {//this锁，这里创建了三个window的对象，执行的时候三个线程三把锁，所以同步方法不用在继承的方式中
		if (ticket > 0) {
			try {
				Thread.currentThread().sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "售票，票号为："
					+ ticket--);
		}
	}
}

public class TestWindow2 {
	public static void main(String[] args) {
		Window2 w1 = new Window2();
		Window2 w2 = new Window2();
		Window2 w3 = new Window2();

		w1.setName("窗口1");
		w2.setName("窗口2");
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();
	}
}
三、静态同步方法
public class SynchronizedTest2 {
    public synchronized static void methodA() {
        try {
            for (int i = 0; i < 3; i++) {
                System.out.println("methodA-" + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB() {
        synchronized (SynchronizedTest2.class) {
            try {
                for (int i = 0; i < 3; i++) {
                    System.out.println("methodB-" + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedTest2 test2 = new SynchronizedTest2();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                test2.methodA();
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                test2.methodB();
            }
        });
        thread2.start();
    }
}
执行结果：
methodA-0
methodA-1
methodA-2
methodB-0
methodB-1
methodB-2

使用synchronized 修饰静态方法时的锁为当前类对象（注意不是当前类实例对象）即：
Class<SynchronizedTest2> aClass = SynchronizedTest2.class;

public class SynchronizedTest3 {
    public synchronized void methodA() {
        try {
            for (int i = 0; i < 3; i++) {
                System.out.println("methodA-" + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void methodB() {
        try {
            for (int i = 0; i < 3; i++) {
                System.out.println("methodB-" + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        SynchronizedTest3 test3 = new SynchronizedTest3();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                test3.methodA();
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                test3.methodB();
            }
        });
        thread2.start();
    }
}
执行结果：
methodA-0
methodB-0
methodA-1
methodB-1
methodA-2
methodB-2

上面代码中，一个方法使用的是实例对象锁，一个方法使用的是类对象锁，两个线程使用两个把锁，可以同时执行。而当两个线程执行同一个类的两个实例对象的非静态方法时，也是同时执行的，原因是锁为两个实例对象，当执行的是静态方法时，两个线程则不能同时执行，因为锁还是同一把锁（类对象）

synchronized可重入锁？
public class Synchronized1 {

    public  synchronized void method1(){
        System.out.println("method1方法执行");
        method2();
    }

    public  synchronized void method2(){
        System.out.println("method2方法执行");
        method3();
    }

    public  synchronized void method3(){
        System.out.println("method3方法执行");
    }

    public static void main(String[] args) {
        Synchronized1 sd1 = new Synchronized1();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                sd1.method1();
            }
        });
        t1.start();
    }
}
执行结果：
method1方法执行
method2方法执行
method3方法执行

上面代码可以看出synchronized 是可重入的，关于重入锁后面单独总结

Liao_Xiang
关注
专栏目录
synchronized三种使用方式(有图)
半页童话
11-06 2761
什么是线程安全 从图中可以看出线程安全只要包括变量在多个线程之间共享、生命周期内状态可以改变、最后结果和预期一致，就是线程安全的。 Synchronized的三种使用方式 1.普通同步方法(实例方法)锁是当前实例对象,进入同步代码前要获得当前实例的锁 2.静态同步方法,锁是当前类的class对象,进入同步代码前要获得当前类对象的锁 3.同步方法块,锁是括号里面的对象,对给定对象加锁,进入同步代...
解决Maven 项目报错 java.httpservlet和synchronized使用方法
08-30
解决Maven项目报错java.httpservlet和synchronized使用方法 在Maven项目中，我们经常会遇到一些报错问题，例如java.httpservlet和synchronized使用方法等。这篇文章将为大家带来解决Maven项目报错java.httpservlet...
synchronized用法详解
最新发布
qq_43842093的博客
03-03 4520
synchronized 是 Java 中的关键字，是一种同步锁。主要应用于多线程环境下保证线程的安全性。A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
synchronized的使用方法
下一个奇迹
05-25 508
记下来，很重要。 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。      二、然而，当一个线程访问ob
Synchronized 使用方式
User_meng的博客
03-10 195
Synchronized 使用方式 修饰到方法上 以下的m1\m2方法上加锁相当于，把锁加在this对象上，所以只有m1下城执行完成m2线程才可以继续执行 public class T1 { private static synchronized void m1() { for (int i = 0; i < 10; i++) { try { Thread.sleep(1000); Syst
synchronized使用方法
04-27
synchronized是Java中用于实现线程同步的关键字，它可以用来修饰方法或代码块，以实现多个线程对共享资源的安全访问。具体使用方法如下： 1. 修饰方法： ``` public synchronized void method(){ //方法体 } ``` ...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
- **synchronized方法**：在方法声明前加上synchronized关键字，使得整个方法成为同步方法。所有调用该方法的线程都需要获取对象锁才能执行。 - **synchronized代码块**：使用`synchronized(obj){...}`结构，其中...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
Java多线程程序中synchronized修饰方法的使用实例
09-02
本篇将深入探讨`synchronized`修饰方法在Java多线程程序中的使用实例。 1. **同步方法** 同步方法是通过在方法声明前加上`synchronized`关键字来实现的。当一个方法被声明为同步时，意味着在同一时刻只有一个线程...
synchronized的使用方法（2）
Heaven_of_relaxing的博客
05-08 508
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。      二、然而，当一个线程访问object的一个s
深入学习Synchronized各种使用方法
weixin_69160215的博客
12-05 2542
在Java当中synchronized通常是用来标记一个方法或者代码块。在Java当中被synchronized标记的代码或者方法在同一个时刻只能够有一个线程执行被synchronized修饰的方法或者代码块。因此被synchronized修饰的方法或者代码块不会出现数据竞争的情况，也就是说被synchronized修饰的代码块是并发安全的。提示：以下是本篇文章正文内容，下面案例可供参考好了，今天的blog就到此为止，期待大佬们的三连和评论。
synchronized的四种用法
qq_44761854的博客
03-07 108
https://www.cnblogs.com/lukelook/p/9946065.html
深入学习锁--Synchronized各种使用方法
weixin_42672802的博客
12-04 1041
深入学习锁--Synchronized各种使用方法
synchronized的使用方法（1）
Heaven_of_relaxing的博客
05-08 521
第一篇： synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。   1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：   public synchronized void accessVal(int newVal);   synchro
synchronized用法
liyang_nash的专栏
02-26 153
1.同时修饰方法和修饰对象this java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。   java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻
Synchronized 的使用
Elroy1230的博客
03-08 391
多线程程序可能经常遇到多个线程尝试访问相同资源并最终产生错误和无法预料的结果的情况。 因此需要通过某种同步方法确保在给定时间点只有一个线程可以访问资源。Java 提供了一种使用同步块创建线程和同步它们的任务的方法。Java 中的同步块用 synchronized 关键字标记。Java 中的同步块在某个对象上同步。在同一个对象上同步的所有同步块一次只能在其中执行一个线程。所有其他试图进入同步块的线程都被阻塞，直到同步块内的线程退出该块。 synchronized(sync_object) { /.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值