[总结] Synchronized汇总
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[总结] Synchronized汇总相关的知识,希望对你有一定的参考价值。
Java中的每一个对象都可以作为锁。
- 1对于同步方法,锁是当前实例对象。
- 2对于静态同步方法,锁是当前对象的Class对象。
- 3对于同步方法块,锁是Synchonized括号里配置的对象。
当一个线程试图访问同步代码块时,它首先必须得到锁,退出或抛出异常时必须释放锁。
我们常引入对象锁和类锁的概念来有助于了解上面的3点论述。
(1)对象锁(对象实例锁)即Synchronized用于对象实例方法,或者一个对象实例上的锁。
(2)类锁是用于类的静态方法或者一个类的class对象上的。
对象锁锁定的是当前实例对象。一个类可以有无数个对象实例,所以一个类可以有无数个对象实例锁。但是每个类只有一个class对象,同一个对象的所有不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁(意味着争夺类锁或者同一个实例的对象锁就会出现同步/锁竞争的情况)。(同时注意: olddoor: 类锁和对象锁并不排斥.)
其实类锁只是一个概念上的东西,并不是真实存在的,它只是用来帮助我们理解锁定实例方法和静态方法的区别的。
比如classs Entity的方法:
public synchronized void objLock(String who){ //使用synchronized修饰方法
for (int i = 0; i < 100; i++) {
System.out.println(who + "-" + i);
}
}
线程类TestThread13如下:
package com.j2se.ThreadTest.test001;
import java.util.Date;
public class TestThread13 extends Thread {
private Entity e;
public TestThread13(Entity e,String name) {
super(name);
this.e=e;
}
public TestThread13(String name) {
super(name);
this.e=e;
}
public void run() {
Entity e =new Entity();
e.objLock(super.getName());//打印当前线程名字
}
}
写一个执行类的main方法执行内容如下
TestThread13 t133=new TestThread13("133");// 实例锁
TestThread13 t1333=new TestThread13("1333"); // 实例锁
t133.start();
t1333.start();
执行效果
1333-0
1333-1
1333-2
133-0
133-1
133-2
133-3
133-4
发现交替打印. 因为线程t133和t1333执行run方法调用Entity.objLock时候调用竞争的是不同的对象实例。
即不同的对象实例锁之间互不干扰(多线程使用不同的对象实例锁),不存在同步竞争情况。
将调用方法改一下
将TestThread13的run方法中的Entity初始化注释 public void run() {
// Entity e =new Entity(); //注释初始化
e.objLock(super.getName());//打印当前线程名字
}
Entity e =new Entity(); //初始化唯一的一个实例,用于传入线程
TestThread13 t133=new TestThread13(e,"133");//
TestThread13 t1333=new TestThread13(e,"1333"); //
t133.start();
t1333.start();
133-0
133-1
133-2
133-3
133-4
133-5
133-6
133-7
133-8
public class TestThread14 extends Thread {
private Entity e;
public TestThread14(Entity e,String name) {
super(name);
this.e=e;
}
public TestThread14(String name) {
super(name);
this.e=e;
}
public void run() {
Entity e =new Entity();
e.classLock(super.getName());//打印当前线程名字
}
}
public synchronized static void classLock(String who){
for (int i = 0; i < 100; i++) {
System.out.println(who + "-" + i);
}
}
TestThread14 t14=new TestThread14("14");//
TestThread14 t144=new TestThread14("144"); //
t14.start();
t144.start();
14-0
14-1
14-2
14-3
14-4
14-5
14-6
...
public void run() {
// Entity e =new Entity();
e.classLock(super.getName());//打印当前线程名字
}
Entity e=new Entity();
TestThread13 t13=new TestThread13(e,"13");//
TestThread14 t14=new TestThread14(e,"14");//
t14.start();
t13.start();
14-0
13-0
13-1
14-1
13-2
public void snycThis(String who) {
synchronized (this) {
for (int i = 0; i < 100; i++) {
System.out.println(who + "-" + i);
}
}
}
package com.j2se.ThreadTest.test001;
import java.util.Date;
public class TestThread15 extends Thread {
private Entity e;
public TestThread15(Entity e,String name) {
super(name);
this.e=e;
}
public TestThread15(String name) {
super(name);
this.e=e;
}
public void run() {
Entity e =new Entity();
e.snycThis(super.getName());
}
}
TestThread15 t15=new TestThread15("15");//
TestThread15 t155=new TestThread15("155");//
t15.start();
t155.start();
155-0
15-0
155-1
15-1
155-2
Entity e=new Entity();
TestThread15 t15=new TestThread15(e,"15");//
TestThread15 t155=new TestThread15(e,"155");//
t15.start();
t155.start();
public void run() {
// Entity e =new Entity(); //不自己初始化, 使用外部传入的对象实例
e.snycThis(super.getName());
}
15-0
15-1
15-2
15-3
15-4
15-5
15-6
15-7
15-8
15-9
15-10
15-11
Entity e=new Entity();
TestThread15 t15=new TestThread15(e,"15");//
TestThread13 t13=new TestThread13(e,"13");//
t15.start();
t13.start();
15-0
15-1
15-2
15-3
15-4
15-5
15-6
15-7
15-8
public synchronized void objLock(String who){
for (int i = 0; i < 100; i++) {
System.out.println(who + "-" + i);
}
}
public void snycThis(String who) {
synchronized (this) {
for (int i = 0; i < 100; i++) {
System.out.println(who + "-" + i);
}
}
}
public void snycClass(String who) {
synchronized (Entity.class) {
for (int i = 0; i < 100; i++) {
System.out.println(who + "-" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public synchronized static void classLock(String who){
for (int i = 0; i < 100; i++) {
System.out.println(who + "-" + i);
}
}
public class Entity {
public String name = "entity";
private static byte[] lock = new byte[0];
private Integer integer=0;
private static LinkedList<AlarmVo> volist = new LinkedList<AlarmVo>();
private String strLock="1";
public void snycstrLock(String who) {
synchronized (strLock) {
for (int i = 0; i < 100; i++) {
System.out.println(who + "-" + i);
}
}
}
- public class ThreadTest_02 extends Thread{
- private String lock ;
- private String name;
- public ThreadTest_02(String name,String lock){
- this.name = name;
- this.lock = lock;
- }
- @Override
- public void run() {
- (lock) {
- for(int i = 0 ; i < 3 ; i++){
- System.out.println(name + " run......");
- }
- }
- }
- public static void main(String[] args) {
- String lock = new String("test");
- for(int i = 0 ; i < 5 ; i++){
- new ThreadTest_02("ThreadTest_" + i,lock).start(); //已改为1个线程的run方法请求5次
- }
- }
- }
运行结果:
ThreadTest_0 run...... ThreadTest_0 run...... ThreadTest_0 run...... ThreadTest_1 run...... ThreadTest_1 run...... ThreadTest_1 run...... ThreadTest_4 run...... ThreadTest_4 run...... ThreadTest_4 run...... ThreadTest_3 run...... ThreadTest_3 run...... ThreadTest_3 run...... ThreadTest_2 run...... ThreadTest_2 run...... ThreadTest_2 run......
在main方法中我们创建了一个String对象lock,并将这个对象赋予每一个ThreadTest2线程对象的私有变量lock。我们知道java中存在一个字符串池,那么这些线程的lock私有变量实际上指向的是堆内存中的同一个区域(加锁则需获取堆内存区域的锁),即存放main函数中的lock变量的区域,所以对象锁是唯一且共享的。线程同步!!
在这里锁住的就是lock这个String对象。{利用String变量指向的是堆内存这一情况, 每个线程实例调用方法时都获取类变量String lock的锁,以此达到同步的效果}
综上 是否可以深刻理解了本文第一句 "Java中的每一个对象都可以作为锁。"
以上是关于[总结] Synchronized汇总的主要内容,如果未能解决你的问题,请参考以下文章