线程的并发与并行
在单CPU系统中,系统调度在某一时刻只能让一个线程运行,虽然这种调试机 制有多种形式(大多数是时间片轮巡为主),但无论如何,要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统 中,可以让两个以上的线程同时运行,这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。
在上面包括以后的所有论述中,请各位朋友谅解,我无法用最准确的词语来定义储如并发和并行这类术语,但我以我的经验能通俗地告诉大家它是怎么一回事,如果您看到我说的一些"标准"文档上说的不一样,只要意思一致,那您就不要挑刺了。
1.synchronized与static synchronized 的区别
synchronized是对类的当前实例进行加锁,防止其他线程同时访问该类的该实例的所有synchronized块,注意这里是“类的当前实例”, 类的两个不同实例就没有这种约束了。那么static synchronized恰好就是要控制类的所有实例的访问了,static synchronized是限制线程同时访问jvm中该类的所有实例同时访问对应的代码快。实际上,在类中某方法或某代码块中有 synchronized,那么在生成一个该类实例后,改类也就有一个监视快,放置线程并发访问改实例synchronized保护快,而static synchronized则是所有该类的实例公用一个监视快了,也也就是两个的区别了,也就是synchronized相当于 this.synchronized,而
static synchronized相当于Something.synchronized.
一个日本作者-结成浩的《java多线程设计模式》有这样的一个列子:
pulbic class Something(){
public synchronized void isSyncA(){}
public synchronized void isSyncB(){}
public static synchronized void cSyncA(){}
public static synchronized void cSyncB(){}
}
那么,加入有Something类的两个实例a与b,那么下列组方法何以被1个以上线程同时访问呢
a. x.isSyncA()与x.isSyncB()
b. x.isSyncA()与y.isSyncA()
c. x.cSyncA()与y.cSyncB()
d. x.isSyncA()与Something.cSyncA()
这里,很清楚的可以判断:
a,都是对同一个实例的synchronized域访问,因此不能被同时访问
b,是针对不同实例的,因此可以同时被访问
c,因为是static synchronized,所以不同实例之间仍然会被限制,相当于Something.isSyncA()与 Something.isSyncB()了,因此不能被同时访问。
那么,第d呢?,书上的 答案是可以被同时访问的,答案理由是synchronzied的是实例方法与synchronzied的类方法由于锁定(lock)不同的原因。
个人分析也就是synchronized 与static synchronized 相当于两帮派,各自管各自,相互之间就无约束了,可以被同时访问。目前还不是分清楚java内部设计synchronzied是怎么样实现的。
结论:A: synchronized static是某个类的范围,synchronized static cSync{}防止多个线程同时访问这个 类中的synchronized static 方法。它可以对类的所有对象实例起作用。
B: synchronized 是某实例的范围,synchronized isSync(){}防止多个线程同时访问这个实例中的synchronized 方法。
2.synchronized方法与synchronized代码快的区别
synchronized methods(){} 与synchronized(this){}之间没有什么区别,只是 synchronized methods(){} 便于阅读理解,而synchronized(this){}可以更精确的控制冲突限制访问区域,有时候表现更高效率。
3.synchronized关键字是不能继承的
这个在http://www.learndiary.com/archives/diaries/2910.htm一文中看到的,我想这一点也是很值得注意的,继承时子类的覆盖方法必须显示定义成synchronized
源于一个想法:比如java中的一个方法
public static void method(){
// ....code
}
是否在前面简单的加上synchronized 就可以实现同步了呢,java真的能帮我们实现吗?
/........................................./
加上synchronized :
public synchronized static void method(){
// ....code
}
/........................................./
我总是不怎么相信,也不确定,这样简单的加上synchronized就能使多线程同步了。但下面的测试让我确定,确实,只要这么简单的做,java就可以实现多线程的同步了。下面看测试代码:
Java代码:
/**
* 测试java多线程的同步,使用5个线程调用载体方法。
*
* 测试用例1:给载体方法加上synchronized修饰词(如程序中)。
* 结果:载体方法被同步,每秒打印一条记录;
*
* 测试用例2:去掉载体方法的synchronized修饰词(请自己试下)。
* 结果:载体方法没有被同步,5条记录很快打印完。
*
* 结论:可想而知!给static方法添上synchronized修饰词,方法就被同步。
* @author ayis
*
* Jan 13, 2009
*/
public class TestSynchronized {
public static void main(String args[]){
// 开启5个线程调用载体方法
TestSynchronized.mutilThreadInvoke(5);
}
/**
* 同步的载体方法
*/
public synchronized static void method(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("method print. time:"+System.currentTimeMillis());
}
/**
* 多线程调用载体方法
* @param n:调用线程的数目
*/
public static void mutilThreadInvoke(int n){
for(int i=0 ; i < n ; i++){
new Thread(
new Runnable(){
@Override
public void run() {
// 调用载体方法
TestSynchronized.method();
}
}
).start();
}
}
}
java线程同步示例代码:
class A {
synchronized void f() {
//同步方法,执行时要获取到该对象的mornitor才do something,如果对象mornitor已被其他线程获取,则等待直到其他线程放弃再锁定该对象
//do something;
}
void g() {
//非同步方法,执行时也要获得该对象的mornitor才do something,如果对象mornitor已被其他线程获取,则等待直到其他线程放弃再锁定
synchronized (this) {
//do something;
}
}
//synchronized不要写错了!上边如果do something完全一样的话,f和g等价,f其实是g的简写
}
加在非static方法上的synchronized方法是和synchronized(this)块等价的,均为对象锁,即对this加锁。获得当前对象锁的线程,可以继续获得当前对象锁,JVM负责跟踪对象被加锁的次数。线程运行B方法,此时如果this锁可以用,线程获得该锁,线程给对象加 锁,计数器变成1,然后B方法调用A方法,由于是对同一个对象同一个线程,线程可以继续获得锁,计数器变为2,表示this被加锁2次。A方法完毕后,线 程释放锁,计数器变为1,此时对象锁对其他线程依然是不可获得的。B方法完毕后,线程继续释放锁,此时计数器变为0,表示锁被完全释放,其他线程可以获得 对象锁。
要明白两个问题,1.锁的对象是谁,2.谁持有了锁。
假设方法A和B是在同一个类Test中的两个方法。
Test t=new Test();
t.methodB();
这个时候,methodB方法被调用时,因为加了synchronized ,需要先获得一个锁,这个锁的对象应该是t,也就是当前的这个Test类的实例,而获得锁的东西是线程,也就是说当前线程拿到了t的锁(而 不是你说的B方法获得锁),这个时候B方法内调用methodA,因为A也加了synchronized,也需要获得一个锁,因为A和B都是Test类中 的方法,所以当前线程要获得的锁的对象也是t。由于当前线程在执行B方法时已经持有了t对象的锁,因此这时候调用methodA是没有任何影响的,相当于 方法A上没有加synchronized。
另一种情况:假设现在有两个Test类
Test t1=new Test();
Test t2=new Test();
t1.methodB();//此时当前线程持有了t1对象的锁
t2.methodB();//此时当前线程也持有了t2对象的锁
当前线程持有了两把锁,锁的对象分别是两个不同的Test类的实例t1和t2,互相没有影响。
再一种情况:假设在多线程环境下,两个线程都可以访问Test t=new Test();
此时假设thread1里调用t.methodB();同时thread2里调用t.methodB()
这时假设thread1先抢到t对象的锁,那么thread2需要等待thread1释放t对象的锁才可以执行B方法。
结果像这样:
thread1获得t的锁--thread1执行methodB--thread1执行methodA--释放t的锁---thread2获得t的锁--thread2执行methodB--thread2执行methodA--释放t的锁。
synchronized还有很多种使用方法,但只有明白是那条线程获得哪个对象的锁,就很容易明白了。
在多线程中使用静态方法是否有线程安全问题
类的成员分为两类,静态成员(static member)和实例成员(instance member)。静态成员属于类,实例成员则属于对象,即类的实例。
简单讨论一下在一个类中使用静态字段(static field)和静态方法(static method)是否会有线程安全问题。
我们在知道, 静态字段(static field)和静态方法(static method)的调用是通过类来调用。静态方法不对特定的实例操作,只能访问静态成员。实例方法可对特定的实例操作,既能访问静态成员,也能访问实例成员。
那么,在多线程中使用静态方法是否有线程安全问题?这要看静态方法是是引起线程安全问题要看在静态方法中是否使用了静态成员。因为,在多线程中使用同一个静态方法时,每个线程使用各自的实例字段(instance field)的副本,而共享一个静态字段(static field)。所以说,如果该静态方法不去操作一个静态成员,只在方法内部使用实例字段(instance field),不会引起安全性问题。但是,如果该静态方法操作了一个静态字段,则需要静态方法中采用互斥访问的方式进行安全处理。
思考:
1.JAVA里静态的方法为什么不能存取“this"所引用的对象
首先要了解静态方法的加载和使用,静态方法也叫类方法。在类被加载的时候被初始化,可以通过类名和对象名进行调用,在类内部可以直接调用。仅该方法不需要实例化对象,即可调用。
在静态的方法中不能以任何形式引用this,因为this默认的对象引用,静态方法被调用时,this所引用的对象并没有产生,this无所指向.
转载:http://www.cnblogs.com/shipengzhi/articles/2223100.html
http://ayis.iteye.com/blog/315792
http://blog.163.com/lang_zi_ming/blog/static/114016176201082795254700/
相关推荐
大家在学习java多线程的时候肯定会遇到这个...static synchronized这个是“全局锁”或者是“类锁”,该锁针对的是类,不管实例了多少个对象,线程都共享该锁。 下面我们来看代码: import java.util.concurrent.TimeUni
Java 中 Synchronized(对象锁)和 Static Synchronized(类锁)的区别 Synchronized 和 Static Synchronized 是 Java 中两种同步机制,它们都用于解决多线程并发访问的安全问题。然而,它们之间存在着本质的区别。...
#### 三、Synchronized与ThreadLocal的区别 - **同步机制:** - Synchronized 是通过加锁来实现同步,确保同一时刻只有一个线程能访问被同步的代码块或方法。 - ThreadLocal 并不提供同步机制,而是为每个线程...
public static synchronized Singleton getInstance() { if (INSTANCE == null) { INSTANCE = new Singleton(); } return INSTANCE; } } ``` 4. 双重检查锁定(DCL):结合了懒汉式的延迟加载和饿汉式的线程...
在 Java 中,synchronized 关键字可以作用于 instance 变量、object reference(对象引用)、static 函数和 class literals(类名称字面常量)身上。 Synchronized 关键字的作用是取得对象的锁,而不是把一段代码或...
public static synchronized void myStaticMethod() { // ... } } ``` 在上面的例子中,synchronized 关键字被用于静态方法 myStaticMethod 上,以防止多个线程同时访问同一个类中的静态方法。 二、synchronized...
public static synchronized void staticMethod() { // 方法体 } } ``` 在这里,`staticMethod`锁定了`MyClass`类的Class对象,因此任何线程调用`staticMethod`都会互斥。 总结来说,`synchronized`关键字在...
public static synchronized void method() { // ... } } ``` - **对象锁**:如果`synchronized`修饰非静态方法或者同步语句块中的对象引用是实例引用,那么锁定的是该实例对象。例如: ```java public ...
除了锁住对象或类,`synchronized`还可以与`wait()`、`notify()`和`notifyAll()`方法结合使用,实现复杂的线程通信和同步。这些方法都是在`Object`类中定义的,只有在持有对象锁的情况下才能调用,否则会抛出`...
2. **同步代码块与非同步代码块的访问** - 如果一个线程正在访问对象的`synchronized(this)`同步代码块,其他线程仍然可以访问该对象的非`synchronized(this)`代码块。例如: ```java package ts; public class...
public static synchronized void staticMethod() { // 方法体 } } ``` ##### 2. 同步代码块 除了同步方法之外,还可以通过`synchronized`关键字来同步一段代码块,这种情况下需要指定同步监视器(锁对象),...
public static synchronized void method() { // 同步方法体 } ``` - 调用此类的静态同步方法时,所有对象都必须等待当前调用方法的线程完成才能继续。 3. **同步状态变量**:在某些情况下,可能需要对某个...
public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread ta = new Thread(t1, "A"); Thread tb = new Thread(t1, "B"); ta.start(); tb.start(); } } ``` 在这个示例中,`Thread1`类...
对于静态(`static`)方法,`synchronized`关键字锁定的是类的Class对象,因此,无论有多少个类的实例,所有线程在访问静态同步方法时都需要获取类的Class对象锁。这意味着,即使有多个类实例,所有线程也无法同时执行...
在方法级别,锁是`this`或`static`方法所属的Class对象;在同步块中,锁是块内指定的对象。同时,应该谨慎使用`synchronized`,因为它会引入性能开销,并可能导致死锁。避免不必要的同步控制,只在绝对必要的地方...
public static synchronized void method() { // ... } } ``` 在这个例子中,`method()`就是一个类锁,多个线程同时调用此方法时,只有一个线程能执行,其他线程必须等待。 **对象锁(Instance Lock)** 对象锁...
synchronized 静态方法修饰一个 static 静态方法,其作用范围是整个静态方法,作用对象是这个类的全部对象。synchronized 类,其作用范围是 Synchronized 后面括号括起来的部分 synchronized(className.class),作用...
2. 某个类的范围,synchronized static 方法可以防止多个线程同时访问这个类中的 synchronized 方法。 synchronized 方法的缺陷 synchronized 方法的缺陷是:同一个对象的不同线程之间会形成互斥,而对这个对象...
3. 对象锁与类锁的区别:如果同步代码块是基于类的静态方法(`static synchronized`),则锁是针对类的,所有实例共享这个锁。而基于实例方法的同步锁是针对实例对象的。 4. 可重入性:一个线程已经拥有某个对象的...