当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法(转)
2016-01-05 08:56
483 查看
对象的synchronized方法不能进入了,但它的其他非synchronized方法还是可以访问的
对每一个class只有一个thread可以执行synchronized static method。每个class的instance只有一个thread可以执行synchronized method。任意数目的thread可以执行非synchronized method——不管是否是static。
情况一:
当一个线程进入一个对象的一个synchronized方法后,其它线程访问该对象的非同步方法。
代码如下:
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod()
{
System.out.println("Invoked synchronizedMethod !") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void generalMethod()
{
System.out.println("Invoked generalMethod ...") ;
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadOne implements Runnable {
private InvokedObject object ;
public ThreadOne(InvokedObject object)
{
this.object = object ;
}
public void run() {
object.synchronizedMethod() ;
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadTwo implements Runnable {
private InvokedObject object ;
public ThreadTwo(InvokedObject object)
{
this.object = object ;
}
public void run() {
// TODO Auto-generated method stub
object.generalMethod() ;
}
}
package com.mutithreading.client;
import com.mutithreading.Object.InvokedObject;
import com.mutithreading.threads.ThreadOne;
import com.mutithreading.threads.ThreadTwo;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
InvokedObject object = new InvokedObject() ;
ThreadOne one = new ThreadOne(object) ;
ThreadTwo two = new ThreadTwo(object) ;
Thread threadOne = new Thread(one) ;
Thread threadTwo = new Thread(two) ;
threadOne.start() ;
threadTwo.start() ;
}
}
运行结果:
情况二:
当一个线程进入一个对象的一个synchronized方法后,其它线程也访问该同步方法。
运行结果:
情况三:
当一个线程进入一个对象的一个synchronized方法后,其它线程同时访问该对象的另一个同步方法。
此处仅给出对InvokedObject类做出的修改代码:
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod1()
{
System.out.println("Invoked synchronizedMethod1 !") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void synchronizedMethod2()
{
System.out.println("Invoked synchronizedMethod2 !") ;
}
}
运行结果:
情况一:
当一个线程进入一个对象的一个synchronized方法后,其它线程访问该对象的非同步方法。
代码如下:
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod()
{
System.out.println("Invoked synchronizedMethod !") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void generalMethod()
{
System.out.println("Invoked generalMethod ...") ;
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadOne implements Runnable {
private InvokedObject object ;
public ThreadOne(InvokedObject object)
{
this.object = object ;
}
public void run() {
object.synchronizedMethod() ;
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadTwo implements Runnable {
private InvokedObject object ;
public ThreadTwo(InvokedObject object)
{
this.object = object ;
}
public void run() {
// TODO Auto-generated method stub
object.generalMethod() ;
}
}
package com.mutithreading.client;
import com.mutithreading.Object.InvokedObject;
import com.mutithreading.threads.ThreadOne;
import com.mutithreading.threads.ThreadTwo;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
InvokedObject object = new InvokedObject() ;
ThreadOne one = new ThreadOne(object) ;
ThreadTwo two = new ThreadTwo(object) ;
Thread threadOne = new Thread(one) ;
Thread threadTwo = new Thread(two) ;
threadOne.start() ;
threadTwo.start() ;
}
}
运行结果:
情况二:
当一个线程进入一个对象的一个synchronized方法后,其它线程也访问该同步方法。
运行结果:
情况三:
当一个线程进入一个对象的一个synchronized方法后,其它线程同时访问该对象的另一个同步方法。
此处仅给出对InvokedObject类做出的修改代码:
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod1()
{
System.out.println("Invoked synchronizedMethod1 !") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void synchronizedMethod2()
{
System.out.println("Invoked synchronizedMethod2 !") ;
}
}
运行结果:
http://blog.csdn.net/hsuxu/article/details/8589108
对每一个class只有一个thread可以执行synchronized static method。每个class的instance只有一个thread可以执行synchronized method。任意数目的thread可以执行非synchronized method——不管是否是static。
情况一:
当一个线程进入一个对象的一个synchronized方法后,其它线程访问该对象的非同步方法。
代码如下:
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod()
{
System.out.println("Invoked synchronizedMethod !") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void generalMethod()
{
System.out.println("Invoked generalMethod ...") ;
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadOne implements Runnable {
private InvokedObject object ;
public ThreadOne(InvokedObject object)
{
this.object = object ;
}
public void run() {
object.synchronizedMethod() ;
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadTwo implements Runnable {
private InvokedObject object ;
public ThreadTwo(InvokedObject object)
{
this.object = object ;
}
public void run() {
// TODO Auto-generated method stub
object.generalMethod() ;
}
}
package com.mutithreading.client;
import com.mutithreading.Object.InvokedObject;
import com.mutithreading.threads.ThreadOne;
import com.mutithreading.threads.ThreadTwo;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
InvokedObject object = new InvokedObject() ;
ThreadOne one = new ThreadOne(object) ;
ThreadTwo two = new ThreadTwo(object) ;
Thread threadOne = new Thread(one) ;
Thread threadTwo = new Thread(two) ;
threadOne.start() ;
threadTwo.start() ;
}
}
运行结果:
一个线程在访问一个对象的同步方法时,另一个线程可以同时访问这个对象的非同步方法。 |
当一个线程进入一个对象的一个synchronized方法后,其它线程也访问该同步方法。
运行结果:
一个线程在访问一个对象的同步方法时,另一个线程不能同时访问这个同步方法。(代码略) |
当一个线程进入一个对象的一个synchronized方法后,其它线程同时访问该对象的另一个同步方法。
此处仅给出对InvokedObject类做出的修改代码:
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod1()
{
System.out.println("Invoked synchronizedMethod1 !") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void synchronizedMethod2()
{
System.out.println("Invoked synchronizedMethod2 !") ;
}
}
运行结果:
一个线程在访问一个对象的同步方法时,另一个线程不能同时访问这个对象的另一个同步方法。 |
当一个线程进入一个对象的一个synchronized方法后,其它线程访问该对象的非同步方法。
代码如下:
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod()
{
System.out.println("Invoked synchronizedMethod !") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void generalMethod()
{
System.out.println("Invoked generalMethod ...") ;
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadOne implements Runnable {
private InvokedObject object ;
public ThreadOne(InvokedObject object)
{
this.object = object ;
}
public void run() {
object.synchronizedMethod() ;
}
}
package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;
public class ThreadTwo implements Runnable {
private InvokedObject object ;
public ThreadTwo(InvokedObject object)
{
this.object = object ;
}
public void run() {
// TODO Auto-generated method stub
object.generalMethod() ;
}
}
package com.mutithreading.client;
import com.mutithreading.Object.InvokedObject;
import com.mutithreading.threads.ThreadOne;
import com.mutithreading.threads.ThreadTwo;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
InvokedObject object = new InvokedObject() ;
ThreadOne one = new ThreadOne(object) ;
ThreadTwo two = new ThreadTwo(object) ;
Thread threadOne = new Thread(one) ;
Thread threadTwo = new Thread(two) ;
threadOne.start() ;
threadTwo.start() ;
}
}
运行结果:
一个线程在访问一个对象的同步方法时,另一个线程可以同时访问这个对象的非同步方法。 |
当一个线程进入一个对象的一个synchronized方法后,其它线程也访问该同步方法。
运行结果:
一个线程在访问一个对象的同步方法时,另一个线程不能同时访问这个同步方法。(代码略) |
当一个线程进入一个对象的一个synchronized方法后,其它线程同时访问该对象的另一个同步方法。
此处仅给出对InvokedObject类做出的修改代码:
package com.mutithreading.Object;
public class InvokedObject
{
public synchronized void synchronizedMethod1()
{
System.out.println("Invoked synchronizedMethod1 !") ;
try {
Thread.sleep(10000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void synchronizedMethod2()
{
System.out.println("Invoked synchronizedMethod2 !") ;
}
}
运行结果:
一个线程在访问一个对象的同步方法时,另一个线程不能同时访问这个对象的另一个同步方法。 |
相关文章推荐
- mysql半同步(semi-sync)源码实现
- Ubuntu环境下挂载新硬盘
- ios百度地图的使用(基本定位和地理编码)
- java里&&与&的区别
- 关系型数据库基础 one
- 一个简单的Java死锁示例(转)
- 线程池的原理及实现(转)
- C++ 中的比較函数
- (转)Ubuntu12.04上NFS Server安装使用过程
- centos 7 samba
- shell数组
- C# Http请求(WebClient,HttpWebRequest)
- Java中,&&与&,||与|的区别
- 安卓 SharedPreferences 的简单使用
- graph slam tutorial : g2o 的使用
- hibernate中联合主键总结_annotation
- ifconfig 说明
- iOS百度地图poi检索(基于百度地图2.3.0SDK开发)
- 大数据系列第四课:scala高阶
- 基于JavaScript代码实现随机漂浮图片广告