`
lclcr
  • 浏览: 125594 次
  • 性别: Icon_minigender_1
  • 来自: 山东
社区版块
存档分类
最新评论

Java线程(二)

    博客分类:
  • JAVA
阅读更多

浅谈synchronized应用于类方法和类字面量之上

       当调用一个synchronized static函数时,获得的lock将与定义该方法的class的Class对象相关联,而不是与调用方法的那个实例对象相关联。当你对一个class literal调用其synchronized代码块时,获得的也是同样那个lock,与特定Class对象相关联的lock,类的所有实例共享 。

public class TestSyncLock {
	public synchronized static void methodOne() { /** 修饰方法 */
			/**
			 * ......
			 */
	}

	public void methodTwo() {		/** 修饰object reference */
		synchronized (TestSyncLock.class) { 
			/**
			 *  ...... 
			 */
		}
	}

	public void methodThree() { 	/** 修饰class literal*/
		synchronized (syncObj) { 	/** syncObj应该为static字面量*/
			/**
			 * ...... 
			 */
		} 
	}
}

       methodOne() 和methodTwo()争取的是同一个lock,也就是TestSyncLock的Class object lock。methodOne()通过synchronized的修饰符取得该lock,methodTwo()则通过class literal TestSyncLock.class得到它。如果synchronized施行于instance方法和object references,得到的lock就与前面的不一样了。对于instance函数,取得的lock隶属于其调用者(某个对象),至于同步控制一个对象(synchronized(syncObj)),取得的当然是该对象(syncObj)的lock。

同步控制(1)instance 方法(2)static 方法(3)对象(object) (4)class literals时得到的lock不同

       举例1.

public class MyRunnable implements Runnable {
	public MyRunnable() {
	}

	private synchronized void printVal() {
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	@Override
	public void run() {
		printVal();
	}

	public static void main(String[] args) {
		MyRunnable run = new MyRunnable();
		Thread tone = new Thread(run, "threadOne");
		tone.start();
		MyRunnable run2 = new MyRunnable();
		Thread ttwo = new Thread(run2, "threadTwo");
		ttwo.start();
	}
}

       说明:上述代码由于是synchronized instance方法,故使用的是instance对象锁,不同的对象具有不同的对象锁。线程tone和线程ttwo使用的是目标对象run和run2的 run()方法,在run()方法中调用了printVal()方法,由于线程访问的是不同对象(run和run2)的synchronized方法,故两个线程可以并行执行,无需等待对象锁。

      如果我们将上面的代码略加修改,即:

private synchronized void printVal() ===> private synchronized static void printVal()

       则其输出就不同了,分别输出,只有一个输出完毕后另一个才会输出。此处我们还假设tone先执行(尽管两个线程tone和ttwo的运行顺序是不定的 ),当tone执行synchronized static void printVal()方法的时候,将会获得类TestSyncLock的Class object lock。当后运行的线程ttwo也执行run()方法时,尽管它们两个访问的对象不同,但是线程ttwo执行到方法printVal()的时候,发现其修饰符为synchronized static,此时它也要求类TestSyncLock的Class object lock,但该锁已经被线程tone锁持有,故ttwo只能等待tone执行完毕后释放该锁。

     举例2.

public class MyRunnable implements Runnable {
	private static byte[] bytes = new byte[0];

	@Override
	public void run() {
		synchronized (bytes) {		//注意这里的bytes为static
			for (int i = 0; i < 5; i++) {
				System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void main(String[] args) {
		MyRunnable run = new MyRunnable();
		Thread tone = new Thread(run, "threadOne");
		tone.start();
		MyRunnable run2 = new MyRunnable();
		Thread ttwo = new Thread(run2, "threadTwo");
		ttwo.start();
	}
}

       说明:经修改后实际和synchronized static void 方法的效果是一样的。

       举例3.

public class TestStaticInstanceRunnable implements Runnable {
	public synchronized void printMOne() {
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + " printMOne .");
		}
	}

	public synchronized static void printMTwo() {
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + " printMTwo .");
		}
	}

	public void run() {
		printMOne();
	}

	@SuppressWarnings("static-access")
	public static void main(String[] args) {
		TestStaticInstanceRunnable run = new TestStaticInstanceRunnable();
		Thread thread = new Thread(run, "thread");
		thread.start();
		run.printMTwo();
	}
}

       说明:在输出时线程main和线程thread交替输出。 线程thread仅仅调用synchronized instance(此处的对象为run)方法printMOne(),在无限循环中打印字符串"printMOne"。主线程main则调用了(此处也是对象run)synchronized static方法printMTwo(),它也进入自身的无限循环中,打印字符串"printMTwo"。

       你或许会以为:由于这两个线程(main线程和thread线程)的执行过程中访问的是同一个对象(run)的两个不同synchronized方法,故无法在上述两方法之间交替。这段代码的输出不是字符串"printMOne"就是字符串"printMTwo"一一取决于哪个线程率先进入其synchronized方法并获得lock。

       然而,当上述代码执行起来,两个字符串都打印在屏幕上,也就是说,两个方法并发执行。

       解析:尽管上述两个方法都声明为synchronized,但它们并非线程安全(thread safe)的,其原因在于一个是synchronized static方法,另一个是synchronized instance方法,因此它们争取的是不同的locks。instance方法printMOne()取得的是TestStaticInstanceRunnable object lock,
static方法printMTwo()取得的是TestStaticInstanceRunnable的Class object lock,是不同的两个locks,彼此互不
影响。

       如果希望上述代码在多线程情况下只有一个线程可以得到锁的话,必须为synchronized锁定的是相同的(相同的instance object或Class object),将方法printOne修改成如下形式,则两个方法是用相同的Class object lock。

public void printMOne() {
	synchronized(TestStaticInstance.class) {
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + " printMOne .");
		}
	}
}	

       如果需要同步控制这段代码,又该怎么办呢?两种选择可以解决这个问题:

       1.同步控制(synchronize)公用资源。       
       2.同步控制(synchronize)—个特殊的instance变量。

       对于1涉及在函数中添加synchronized语句,以便同步控制共享资源。假设两个方法要更新同一个对象,它们就对其进行同步控制。

public class TestSyncLock {
	private SyncObj syncObj;
	public void methodOne () {			
		synchronized (syncObj) {
			/**
			 * ......
			 */
		}
	}
	public static void methodTwo (TestSyncLock syncLock) {
		synchronized (syncLock.syncObj) {
			/**
			 * ......
			 */
		}
	}
}

       对于2涉及声明一个local instance 变量,惟一的目的就是对它进行同步控制。

public class TestSyncLock {
	private byte [] lock = new byte[0];
	public void methodOne () {			
		synchronized (lock) {
			/**
			 * ......
			 */
		}
	}
	public static void methodTwo (TestSyncLock syncLock) {
		synchronized (syncLock.lock) {
			/**
			 * ......
			 */
		}
	}
}

       由于你只能锁定对象,你使用的local instance 变量必须是个对象。至于为什么使用一个元素个数为0的字节数组,其原因是字节数组比其他任何对象都经济。

       上述两种做法中的任何一种都使代码成为线程安全(thread safe)的。同步控制通过instance方法或object reference所取得的lock,完全不同于同步控制通过static方法或class literal 所取得的lock。两个方法被声明为synchronized并不就意味它们具备线程安全性。

public class TestStaticInstanceRunnable implements Runnable {
	private byte [] bytes = new byte[0];          //关键在于多线程中锁一定是相同的
	public void printMOne() {
		synchronized(bytes) {
			while (true) {
				/** ...... */
			}
		}
	}

	public static void printMTwo(TestStaticInstanceRunnable run) {
		synchronized(run.bytes) {
			while (true) {
				/** ...... */
			}
		}
	}

	public void run() {
		printMOne();
	}

	@SuppressWarnings("static-access")
	public static void main(String[] args) {
		TestStaticInstanceRunnable run = new TestStaticInstanceRunnable();
		Thread thread = new Thread(run, "thread");
		thread.start();
		run.printMTwo(run);
	}
}

  <<To Be Continued>>

分享到:
评论

相关推荐

    线程 JAVA java线程 java线程第3版 java线程第2版第3版合集

    java线程第二版中英文 java线程第二版中英文 线程并不是新的概念:许多操作系统和语言都支持它们。在Java出现以前,似乎人人都在谈论线程,却很少有人使用它。用线程编程是技巧性很强的且不可移植。 而在Java中却...

    java 线程工具类 java 线程工具类

    java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具...

    java线程.pdf

    根据提供的信息,我们可以推断出这份文档主要关注的是Java线程的相关内容。下面将围绕“Java线程”这一主题展开详细的介绍与解释。 ### Java线程基础 在Java语言中,线程是程序执行流的基本单元。一个标准的Java...

    Java线程高清晰中文第二版

    在Java出现以前,似乎人人都在谈论线程,却很少有人使用它。用线程编程是技巧性很强的且不可移植。 而在Java中却完全不同。Java的线程工具易于使用,并且像Java中的其他东西一样可以在不同的平台之间移植。这是一件...

    Java线程状态流转图

    Java线程状态流转图知识点总结 Java线程状态流转图是一种用于描述Java线程生命周期中不同的状态和状态转换的图形表示方式。该图形展示了Java线程从创建到终止的整个生命周期,并详细介绍了每种状态的特点和转换...

    Java线程详解大全

    Java线程是并发编程的核心部分,它允许程序在同一时间执行多个独立的任务,从而提高系统效率和响应速度。本文将深入探讨Java线程的概念、生命周期、实现方式以及相关的同步机制。 首先,理解线程的基本概念至关重要...

    java 线程 dump 分析工具 2.3.3

    java 线程Dump 分析工具: Java的TDA线程转储分析器是一个用于分析Sun Java VM生成的线程转储和堆信息的小型Swing GUI(目前用1.4测试)。它从提供的日志文件中解析线程转储和类直方图。它提供关于发现的线程转储的...

    Java线程.ppt

    Java线程是Java编程中的重要概念,特别是在多核处理器和并发处理中不可或缺。Java线程允许程序在同一时间执行多个不同的任务,从而提高了程序的效率和响应性。在燕山大学信息学院计算机系的课程中,李峰教授讲解了...

    Java线程使用教程

    Java线程是Java编程语言中的一个核心概念,它允许程序同时执行多个任务,极大地提高了程序的并发性和效率。本教程将深入探讨Java线程的使用,帮助开发者掌握这一关键技术。 一、线程基础 1. **线程的概念**:线程...

    Java线程(第三版)

    《Java线程(第三版)》是一本深入探讨Java线程技术的专业书籍,旨在帮助开发者理解和掌握Java平台上的多线程编程。Java线程是并发编程的重要组成部分,它允许程序同时执行多个任务,从而充分利用系统资源,提高程序的...

    java多线程Demo

    Java线程有10个优先级(MIN_PRIORITY, NORM_PRIORITY, MAX_PRIORITY),默认优先级是NORM_PRIORITY。但是,线程优先级并不保证绝对的执行顺序,操作系统调度策略可能影响实际执行顺序。 7. join()方法: 一个线程...

    java线程实例 各种小Demo

    Java线程是多任务编程的重要概念,它允许程序同时执行多个独立的任务,从而提高系统效率和响应速度。在Java中,线程可以分为用户线程和守护线程,前者是程序运行的基础,而后者是在所有用户线程结束时才终止的后台...

    java线程分析工具TDA

    Java线程分析是Java开发中的重要环节,尤其是在处理性能优化、死锁排查或者并发问题时。TDA(Thread Dump Analyzer)是一款强大的Java线程分析工具,它能够帮助开发者深入理解应用在运行时的线程状态,包括线程的...

    java线程深入解析

    Java线程是Java编程语言中的核心概念,尤其在多任务处理和并发编程中扮演着重要角色。线程允许一个程序内部同时执行多个独立的控制流,使得程序能够更高效地利用处理器资源。本文将深入解析Java线程的相关知识点,...

    JAVA线程dump的分析

    JAVA线程dump的分析 JAVA线程dump是指在JAVA程序中,当前线程的状态和调用堆栈的快照,能够帮助开发者了解当前程序的执行情况,诊断问题和性能瓶颈。生成JAVA线程dump的方法在不同的操作系统下是不同的,在Windows...

    java 线程相关工具类

    java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类....

    java线程入门级书籍

    #### 二、Java线程的使用场景 **2.1 提高用户界面响应速度** 在使用Swing等GUI库时,事件驱动的用户界面需要一个专门的事件线程来处理用户的输入。如果某个事件处理函数(如事件监听器)执行时间过长,会导致用户...

    java线程文档大全

    Java线程是多任务编程中的核心概念,它允许程序同时执行多个不同的任务,极大地提高了程序的效率和响应性。在Java中,线程是通过Java.lang.Thread类或实现Runnable接口来创建和管理的。这份“java线程文档大全”包含...

    JAVA线程学习(源代码)

    本资源"JAVA线程学习(源代码)"提供了关于Java线程的源代码示例,帮助我们深入理解和实践线程的使用。 首先,我们要理解Java中的线程模型。Java线程由`java.lang.Thread`类或`java.util.concurrent.Executor`框架来...

    Java多线程设计模式上传文件

    Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式...

Global site tag (gtag.js) - Google Analytics