java的同步机制，大概是通过
1.synchronized；
2.Object方法中的wait,notify；
3.ThreadLocal机制
来实现的
其中synchronized有两种用法
1.对类的方法进行修饰
2.synchronized(对象）的方法进行修饰
所以我们这里有好几种场景，现在我对每个场景都举个例子说明，并且指出哪个例子是说明哪个场景的。最后说为什么需要ThreadLocal，以及ThreadLocal的用法。例子结合了从网上找的资料。
所有场景都要用到的类
|
package threadlocal.test;
public class Student {
private int age = 0;
public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
}
|
一，第一个应用场景，无任何同步机制，整个程序运行时间约为5秒
|
package threadlocal.test;
import java.util.Random;
public class ThreadDemo1 implements Runnable {
Student student = new Student();
public static void main(String[] agrs) {
ThreadDemo1 td = new ThreadDemo1();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
t1.start();
t2.start();
}
public void run() {
accessStudent();
}
public void accessStudent() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
Random random = new Random();
int age = random.nextInt(100);
System.out
.println("thread " + currentThreadName + " set age to:" + age);
this.student.setAge(age);
System.out.println("thread " + currentThreadName
+ " first read age is:" + this.student.getAge());
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("thread " + currentThreadName
+ " second read age is:" + this.student.getAge());
}
}
|
简述：两个线程同时开启，对同一个类实例进行操作，虽然速度很快，只占用一个线程运行时间，但是出现竞争使得整个代码变得无用。
二，第二个应用场景，synchronized修饰类方法。程序运行时间约为10秒
|
package threadlocal.test;
import java.util.Random;
/**
* 加了个synchronized，不会出现竞争了，但是效率极低
*
* @author dachuan
*
*/
public class ThreadDemo2 implements Runnable {
Student student = new Student();
public static void main(String[] agrs) {
ThreadDemo2 td = new ThreadDemo2();
// ThreadDemo2 td = new ThreadDemo2();
// ThreadDemo2 td2 = new ThreadDemo2();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
//之所以t1,t2两个线程会在acessStudent函数处出现同步，是因为他们都是对同一个实例的函数进行访问
//t1,t2都在对ThreadDemo2这个类的实例td的函数accessStudent进行访问，所以会出现同步。
//也就是说，如果类A内部定义了一个synchronized方法，而a是A的一个实例，如果有不同的线程都对a.syn()进行访问，就会出现同步
//synchronized关键字是锁住了类的实例，让另外的线程进不去
//在这个例子中，t1,t2两个线程，总共运行时间肯定>=10秒，因为t1,t2在accessStudent这个地方是串行的。
//如果t1,t2是为了完成某件事情在合作，那么这个同步是值得的。
//现在的前提是，t1,t2必须使用同一个类的实例，但是又做的都是独立的事情。这个时候，synchronized方法显得很低效，反而降低了运算效率
//所以ThreadLocal的出现就是为了解决这个问题的。
//ThreadLocal的应用场合：
//1.多个线程都要使用同一个类实例
//2.这多个线程拿到这个类实例后做的事情是互相独立的
//生产者和消费者模型跟ThreadLocal的应用场合有一个区别
//1.生产者和消费者两个线程其实也是在使用同一个类实例
//2.但是这两个线程拿到类实例后做的事情是互相牵制的
t1.start();
t2.start();
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
accessStudent();
}
public synchronized void accessStudent() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
// System.out.println("first read age is:"+this.student.getAge());
Random random = new Random();
int age = random.nextInt(100);
System.out
.println("thread " + currentThreadName + " set age to:" + age);
this.student.setAge(age);
System.out.println("thread " + currentThreadName
+ " first read age is:" + this.student.getAge());
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("thread " + currentThreadName
+ " second read age is:" + this.student.getAge());
}
}
|
简述：两个线程在accessStudent方法处串行操作，所以整个程序时间变长，大约10秒。消除了竞争
三，第三个应用场景，synchronized修饰类，程序运行时间大约10秒。
|
package threadlocal.test;
import java.util.Random;
/**
*
* @author dachuan
*
*/
public class ThreadDemo3 implements Runnable {
Student student = new Student();
public static void main(String[] agrs) {
ThreadDemo3 td = new ThreadDemo3();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
t1.start();
t2.start();
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
accessStudent();
}
public void accessStudent() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
// System.out.println("first read age is:"+this.student.getAge());
synchronized (this) {
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread " + currentThreadName + " set age to:"
+ age);
this.student.setAge(age);
System.out.println("thread " + currentThreadName
+ " first read age is:" + this.student.getAge());
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
System.out.println("thread " + currentThreadName
+ " second read age is:" + this.student.getAge());
}
}
|
简述：synchronized关键字都是用来锁住对象的，这个地方锁住了this，两个线程访问的都是同一个类实例，所以两个线程中的this都是指一个东西。整个程序无竞争，运行时间大约10秒
四，第四个应用场景，TheadLocal。程序无竞争，运行时间大约5秒
|
package threadlocal.test;
import java.util.Random;
public class ThreadLocalDemo implements Runnable {
private final static ThreadLocal studentLocal = new ThreadLocal();
public static void main(String[] agrs) {
ThreadLocalDemo td = new ThreadLocalDemo();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
t1.start();
t2.start();
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
accessStudent();
}
public void accessStudent() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
Random random = new Random();
int age = random.nextInt(100);
System.out
.println("thread " + currentThreadName + " set age to:" + age);
Student student = getStudent();
student.setAge(age);
System.out.println("thread " + currentThreadName
+ " first read age is:" + student.getAge());
try {
Thread.sleep(5000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("thread " + currentThreadName
+ " second read age is:" + student.getAge());
}
protected Student getStudent() {
Student student = (Student) studentLocal.get();
if (student == null) {
student = new Student();
studentLocal.set(student);
}
return student;
}
protected void setStudent(Student student) {
studentLocal.set(student);
}
}
|
简述：ThreadLocal的出现使得两个线程虽然手中握有同一个类的实例，但是做同一样事情的时候却互不干扰。这就是ThreadLocal的应用场景。
五，第五个应用场景，生产者&消费者模型和ThreadLocal模型的区别
我个人总结，ThreadLocal的应用场景为：
1.多个线程都要使用同一个类实例
2.这多个线程拿到这个类实例后做的事情是互相独立的
而生产者消费者例子跟ThreadLocal有一点区别
1.生产者和消费者两个线程其实也是在使用同一个类实例
2.但是这两个线程拿到类实例后做的事情是互相牵制的
所以看到这里，就知道ThreadLocal的应用场景是什么了。
我在阅读Hadoop源码时，看到MapOutputFile这个类中使用了ThreadLocal，所以查了些资料总结了下。
在Hadoop源码中，有一处地方对Object的wait和notify进行了很好的诠释。以后有空再记录一下。
阅读(560) | 评论(0) | 转发(0) |
