Java多线程基础(三)Java传统线程互斥技术
java的线程互斥主要通过synchronized关键字实现。下面的示例代码展示了几种使用synchronized关键字的基本用法。
package com.ming.thread;
public class TestThread {
public static void main(String[] args) {
TestThread test=new TestThread();
test.init();
//test.init1();
}
private void init(){
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//num.sayHello("123456789");
//num.sayHello1("123456789");
//num.sayHello3("123456789");
//num.sayHello4("123456789");
final Num num=new Num();
num.sayHello5("123456789");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//num.sayHello("chenhuaming");
//num.sayHello1("chenhuaming");
//num.sayHello3("chenhuaming");
//num.sayHello4("chenhuaming");
final Num num=new Num();
num.sayHello5("chenhuaming");
}
}
}).start();
}
private void init1(){
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//Num.sayHello11("123456789");
Num.sayHello12("123456789");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//Num.sayHello11("chenhuaming");
Num.sayHello12("chenhuaming");
}
}
}).start();
}
static class Num{
String _lock ="";
final static String final_lock="";
//线程不安全
/*
* 多个操作者(线程)必须操作同一个对象
*/
public void sayHello(String name){
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
//线程不安全
/*
* 原因:
* 锁对象不互斥,锁对象应该使用共享对象
* 解决方案如:sayHello2 sayHello3 sayHello4
*/
public void sayHello1(String name){
synchronized (name) {
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
//线程安全
/*
* 方法1:
*
* 使用共享类对象作为对象锁
*/
public void sayHello2(String name){
synchronized (this) {
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
//线程安全
/*方案2:
*
* 以自定义对象作为锁对象,
* 与使用_lock加锁的代码块互斥
*/
public void sayHello3(String name){
synchronized (_lock ) {
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
//线程安全
/*
* 同步方法
*/
public synchronized void sayHello4(String name){
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
public void sayHello5(String name){
synchronized (Num.class) {
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
/**************静态方法************/
//线程不安全
public static void sayHello11(String name){
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
//线程安全
public static void sayHello12(String name){
synchronized (final_lock) {
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
//线程安全
public static void sayHello13(String name){
synchronized (Num.class) {
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
//线程安全
public synchronized static void sayHello14(String name){
int len = name.length();
for(int i=0; i<len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
上面的代码中展示了三种基本的线程互斥实现。下面详述三种方法的实现特点和适用情况。
以this作为锁对象
实现方式
synchronized(this){…}
synchronized实例方法
适用情况
适用于使用类的同一个实例(对象)作为锁对象。下面情况不适用:
若上述代码中第26行和第39行,改为
new Printer().output(“<相应字符串>”);
则无法使用本方法实现线程互斥,而须采用第2种方法。
以Outputer.class作为锁对象
Outputer类的字节码对象由jvm自动加载。
实现方式
synchronized(Outputer.class){…}
static synchronized方法
适用情况
适用于整个类的所有对象都需要互斥访问的情况。
以自定义的对象作为所对象
实现方式
synchronized(<自定义锁对象>){…}
适用情况
同一个类中代码块或者方法的互斥,一般可以用第1种和第2种方法替换。当出现需要在多个类(或者多个类的实例)之间进行互斥控制时,可能需要采用本方法。