Java多线程2：synchronized

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量674 收藏
点赞数
分类专栏： java 文章标签： java 多线程 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011796274/article/details/22443535
版权

synchronized

先看一段代码： 
public class Account {

	private int money;

	public Account(int money) {
		this.money = money;
	}
	
	public void deposit(int my) {
		int tmp = this.money;
		tmp += my;
		try {
			Thread.sleep((int)(Math.random() * 1000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.money = tmp;
	}
	
	public void withdraw(int my) {
		int tmp = this.money;
		tmp -= my;
		try {
			Thread.sleep((int)(Math.random() * 1000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.money = tmp;
	}
	
	public int getMoney() {
		return money;
	}
	
	private static final int THREAD_AMOUNT = 100;
	private static Thread[] threads = new Thread[THREAD_AMOUNT];
	public static void main(String[] args) {
		final Account account = new Account(1000);
		for (int i = 0; i < THREAD_AMOUNT; i++) {
			threads[i] = new Thread(new Runnable() {
				@Override
				public void run() {
					account.deposit(100);
					account.withdraw(100);
				}
			});
			threads[i].start();
		}
		for (int i = 0; i < THREAD_AMOUNT; i++) {
			try {
				threads[i].join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		System.out.println("money is " + account.getMoney());
	}
}
我们用Account模拟一个账户。然后启动1000个线程，对账户中的1000元进行存取。我们先存100元，再取100元，结果应该是1000元不变。但是事与愿违，我们的结果是1000、1100等随机结果。原因是当一个线程存了100元，还没有被取走时，另一个线程的结果把当前的值覆盖掉了。这就需要我们对方法进行同步。 
public synchronized void deposit(int my) {

}
	
public synchronized void withdraw(int my) {

}
这样就能得到正确结果了，但是运行时间貌似增加了~~囧。

下面我们来介绍一下synchronized：
synchronized可以作为方法的修饰符，也可以出现在代码中，如： 
synchronized(o) {
    //your code
}
o是一个Object类型
1.当synchronized修饰方法的时候，就相当于类实例的该方法加了一把锁（是每个类实例都拥有各自的锁，而不是所有类实例共享一把锁）。 
public class ThreadTest {
	
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass pc = new PrintClass();
				pc.printText("thread-1");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass pc = new PrintClass();
				pc.printText("thread-2");
			}
		});
		t1.start();
		t2.start();
	}

}

class PrintClass {
	
	public synchronized void printText(String text) {
		while(true) {
			System.out.println(text);
		}
	}
}
上面的demo，这两个线程都会打印，因为每个线程中都持有一个实例，这两个实例的synchronized方法锁并不互斥。但如果改为下面这样： 
public class ThreadTest {
	
	public static void main(String[] args) {
		final PrintClass pc = new PrintClass();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				pc.printText("thread-1");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				pc.printText("thread-2");
			}
		});
		t1.start();
		t2.start();
	}

}

class PrintClass {
	
	public synchronized void printText(String text) {
		while(true) {
			System.out.println(text);
		}
	}
}
只有一个线程会打印出来，因为他们持有的同一个实例。要是synchronized修饰的是静态方法又会怎样呢： 
public class ThreadTest {
	
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass.printText("thread-1");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass.printText("thread-2");
			}
		});
		t1.start();
		t2.start();
	}

}

class PrintClass {
	
	public synchronized static void printText(String text) {
		while(true) {
			System.out.println(text);
		}
	}
}
还是只有一个线程会打印。这是因为在静态方法上使用synchronized，是在这个类的静态方法上加了把锁，同一时刻只能有一个线程访问该静态方法。
2.当synchronized修饰代码块的时候，在谁的身上加锁取决于synchronized(o) {}中的对象o。在这里你可以把o看成一个门卫，进入synchronized标注的代码块必须取得门卫的同意，门卫每次只放一个线程进入。一个门卫可以看管多个代码块，同一个门卫只允许同一个线程进入。
我们最常见到的门卫是this： 
public class ThreadTest {

	public static void main(String[] args) {
		final PrintClass pc = new PrintClass();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				pc.printText("Thread-1:text1", "Thread-1:text2", "Thread-1:text3");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				pc.printText("Thread-2:text1", "Thread-2:text2", "Thread-2:text3");
			}
		});
		t1.start();
		t2.start();
	}
	
}

class PrintClass {
	
	public void printText(String text1, String text2, String text3) {
		System.out.println(text1);
		synchronized (this) {
			for(int i=0; i < 1000; i++) {
				System.out.println(text2);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		System.out.println(text3);
	}
}
运行结果是：
Thread-1:text1
Thread-1:text2
Thread-2:text1
Thread-1:text2
Thread-1:text2
Thread-1:text2
           .
           .
           .
我们看Thread-1和Thread-2都进入了该方法，但是只有Thread-1进入了同步块，Thread-2被阻塞了，所以text3也未打印出。我们再看一个同一个门卫看守两块代码的例子： 
public class ThreadTest {

	public static void main(String[] args) {
		final PrintClass pc = new PrintClass();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				pc.printText("text");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				pc.printVal(1111);
			}
		});
		t1.start();
		t2.start();
	}
	
}

class PrintClass {
	
	public void printText(String text) {
		synchronized (this) {
			while(true) {
				System.out.println(text);
			}
		}
	}
	public void printVal(int val) {
		synchronized (this) {
			while(true) {
				System.out.println(val);
			}
		}
	}
}
这段代码只能打印出一种结果，原因是这个两个方法都是门卫this来看管的，他只让一个线程通过，即使是不同的代码块。其实由this看管的代码块相当于在类的方法上加synchronized（不包括静态方法哦！），是在类实例上加锁的。如果是新的实例，那么this就不是同一个了。不同的门卫this就可以让不同的线程进入了，这里就不在举例了，那我们在看看其他的门卫： 
public class ThreadTest {

	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass pc = new PrintClass();
				pc.printText("text");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass pc = new PrintClass();
				pc.printVal(1111);
			}
		});
		t1.start();
		t2.start();
	}
	
}

class PrintClass {
	
	public void printText(String text) {
		synchronized (PrintClass.class) {
			while(true) {
				System.out.println(text);
			}
		}
	}
	public void printVal(int val) {
		synchronized (PrintClass.class) {
			while(true) {
				System.out.println(val);
			}
		}
	}
}
这次是这个类来作门卫了，虽然我们使用了2个类实例（在run方法里new了两个实例），但这次还是只打印出一种结果，这就是类同步。就相当于在静态方法上加synchronized，这个代码块同一时间只允许一个线程访问。你可以试试将PrintClass.class换成this，这样两个方法都可以打印出结果的。其实添加一个静态成员变量，用他做门卫，也可以达到上面demo的效果： 
public class ThreadTest {

	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass pc = new PrintClass();
				pc.printText("text");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass pc = new PrintClass();
				pc.printVal(1111);
			}
		});
		t1.start();
		t2.start();
	}
	
}

class PrintClass {
	
	private static Object lock = new Object();
	public void printText(String text) {
		synchronized (lock) {
			while(true) {
				System.out.println(text);
			}
		}
	}
	public void printVal(int val) {
		synchronized (lock) {
			while(true) {
				System.out.println(val);
			}
		}
	}
}
因为静态成员变量是类持有的，每个实例共享的，所以这样加锁与给类本身加锁效果相同。但要是只是普通的成员变量呢，在这里我们用String这个对象来举例： 
public class ThreadTest {

	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass pc = new PrintClass();
				pc.printText("text");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				PrintClass pc = new PrintClass();
				pc.printVal(1111);
			}
		});
		t1.start();
		t2.start();
	}
	
}

class PrintClass {
	
	private String str = new String();
	
	public void printText(String text) {
		synchronized (str) {
			while(true) {
				System.out.println(text);
			}
		}
	}
	public void printVal(int val) {
		synchronized (str) {
			while(true) {
				System.out.println(val);
			}
		}
	}
}
打印出了2种结果，证明这String对象是被类实例持有的，所以只针对类实例加锁。但是，试一试将定义改为private String str = ""。呵呵，只打印出一种结果吧。原因可能是JVM虚拟机优化了String，使之在赋值之后不可变了，所以这个门卫始终就是他一人了。
最后，还要注意一点，方法上的synchronized是不能继承的哦，子类想要同步，要在方法上自己添加。


我是一休哥
关注
专栏目录
JAVA多线程基础学习二：synchronized
m0_54828003的博客
08-05 175
synchronized()，()中是锁住的对象， synchronized(this)锁住的只是对象本身，同一个类的不同对象调用的synchronized方法并不会被锁住，而synchronized(className.class)实现了全局锁的功能，所有这个类的对象调用这个方法都受到锁的影响，此外()中还可以添加一个具体的对象，实现给具体对象加锁。两个线程间是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。...
java中的多线程2.锁synchronized
zb_andy_j的博客
09-11 135
锁 synchronized synchronized锁的目标 对象 public class Test_Sync01 { Object o = new Object(); public void test() { synchronized (o) { System.out.println("o is synchronzied"); } } } this或者方法体。它们锁的都是当前对象。 public class Test_Sync02 { public synchr
Java多线程4：synchronized的使用场景和原理简介
何哥的博客
09-06 2984
一、synchronized使用 1.1 synchronized介绍 在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对synchronized进行了各种优化之后，有些情况下它就并不那么重了。 synchronized可以修饰普通方法，静态方法和代码块。当synchronize...
Java多线程之synchronized
qq_35716085的博客
07-20 6279
synchronized具有同步功能，是一种互斥锁，锁的是对象。如果既想保证共享变量的可见性和有序性，又想保证原子性，那么synchronized关键字是一个不错的选择。synchronized的缺点：1.synchronized底层是由jvm实现，因此不能手动控制锁的释放，不如lock锁灵活，synchronized修饰的方法一旦出现异常，jvm保证锁会被释放（lock锁需要在finally中释放）。2.synchronized是非公平锁，不保证公平性。
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 23万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
Java多线程中使用synchronized说明
12-22
在Java多线程编程中，`synchronized`有多种用法，包括修饰实例方法、静态方法以及作为代码块来锁定特定的对象引用。 1. **修饰实例方法**： 当`synchronized`关键字用于实例方法时，它会对该实例对象加锁。这意味...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
java多线程编程之Synchronized块同步方法
09-03
在Java多线程编程中，`synchronized`关键字是一个至关重要的概念，用于实现线程间的同步，以确保共享资源的安全访问。本篇文章将深入探讨`synchronized`块同步方法及其应用，通过实例来阐述其工作原理。 首先，我们...
java多线程编程之Synchronized关键字详解
09-02
在Java多线程编程中，`Synchronized`关键字扮演着至关重要的角色，它主要用于实现线程之间的互斥访问，确保共享资源的安全性。本篇将深入解析`Synchronized`关键字，探讨其工作原理以及在实际应用中的注意事项。 一...
Java多线程程序中synchronized修饰方法的使用实例
09-02
本篇将深入探讨`synchronized`修饰方法在Java多线程程序中的使用实例。 1. **同步方法** 同步方法是通过在方法声明前加上`synchronized`关键字来实现的。当一个方法被声明为同步时，意味着在同一时刻只有一个线程...
java rsa加密解密
u011796274的专栏
08-06 1321
rsa加密：用公钥加密，用私钥解密。
tomcat中配置mime类型
u011796274的专栏
04-09 1301
a
解决hibernate写入mysql中文乱码问题
u011796274的专栏
05-17 928
1.创建数据数据库时设定编码为utf-8
Java多线程3：wait、notify和notifyAll
u011796274的专栏
03-31 660
wait、notify和notifyAll 首先，这些方法属于Object，而不属于Thread。其次，obj.wait()、obj.notify()必须要与synchronized(obj)一起使用，也就是说obj.wait()、obj.notify()必须存在于synchronized(obj){...}的代码块内（http://blog.csdn.net/u011796274/articl
Java多线程1：线程基础
u011796274的专栏
03-26 617
一个线程的生命周期： 新状态：一个新产生的线程从新状态开始了它的生命周期。它保持这个状态知道程序start这个线程。 运行状态：当一个新状态的线程被start以后，线程就变成可运行状态，一个线程在此状态下被认为是开始执行其任务。 就绪状态：当一个线程等待另外一个线程执行一个任务的时候，该线程就进入就绪状态。当另一个线程给就绪状态的线程发送信号时，该线程才重新切换到运行状态。 休眠状
Java-网络
最新发布
2301_81543552的博客
09-14 687
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 598
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 271
【代码】自动生成不重复的订单id。
Java多线程同步：Synchronized块详解与示例
在Java多线程编程中，Synchronized块同步方法是确保线程安全的重要手段，它利用`synchronized`关键字来控制并发访问。`synchronized`关键字可以用于方法或者代码块，其核心作用是提供互斥访问，即在同一时刻只有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值