java-线程同步问题

1.Timer类

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo {

    public static void main(String[] args) throws Exception{
        /*
         * Timer类的演示：ava.util.Timer类是一个定时器，可以让它定时做某件事情，
         * 方法：schedule(task,delay,period);//在delay毫秒后执行task,并以period为周期循环执行。
         *       
         * */
        Timer t=new Timer();
//        t.schedule(new TimerTask ()
//        {
//            @Override
//            public void run() {
//                System.out.println("bombing!!!"); 
//             }
//         }, 3000);
          
        t.schedule(new MyTimerTask(), 3000);
        //每隔一秒，打印出时间
        while(true)
        {
            System.out.println(new Date().getSeconds());
            Thread.currentThread().sleep(1000);
        }
      }
}
//实现了每3秒爆炸，每2秒爆炸，并以此循环
//写成类的原因是：我们要不停的使用该类中的run代码，
//这样可以通过不停的new对象出来重复使用run代码
//int i写成静态的原因是：new的对象要共享数据i，所以写成静态
//i=(i+1)%count,的结果是i以count的为周期，不停循环。
//注意：这里不能写成TimerDemo的内部类，因为一个非静态的内部类相当于其他非静态的方法，不能在
//     里面声明静态变量(static int i)!!或静态方法！！
class MyTimerTask extends TimerTask {
    static int i=0;
    @Override
    public void run() {
            System.out.println("bombing!!!");
            new Timer().schedule(new MyTimerTask() , (i+2)*1000);
            i=(i+1)%2;
     }
}

2.多个线程访问共享对象和数据的方式

    2.1 如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就可以这么做。

    2.2 如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：

           a.将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，

              这样容易实现针对该数据进行的各个操作的互斥和通信。

           b.将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现

             对共享数据进行的各个操作的互斥和通信，作为内部类的各个Runnable对象调用外部类的这些方法。

           上面两种方式的组合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量

                                       每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。

      总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通信。

      极端且简单的方式，即在任意一个类中定义一个static的变量，这将被所有线程共享。

3.ThreadLoal解决线程同步问题(http://blog.csdn.net/qjyong/article/details/2158097)

      对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。

      前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

    ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为线程局部变量(ThreadLocalVariable)更容易让人理解一些。

    ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

• void set(Object value)

    设置当前线程的线程局部变量的值。

• public Object get()

    该方法返回当前线程所对应的线程局部变量。

• public void remove()

    将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，

    对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

• protected Object initialValue()

    返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，

    在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

    值得一提的是，在JDK5.0中，ThreadLocal已经支持泛型，该类的类名已经变为ThreadLocal<T>。

    API方法也相应进行了调整，新版本的API方法分别是void set(T value)、T get()以及T initialValue()。

public class SequenceNumber {

①通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值

private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>(){

public Integer initialValue(){

return 0;

}

};

②获取下一个序列值

public int getNextNum(){

seqNum.set(seqNum.get()+1);

return seqNum.get();

}

public static void main(String[] args)

{

SequenceNumber sn = new SequenceNumber();

③ 3个线程共享sn，各自产生序列号

TestClient t1 = new TestClient(sn);

TestClient t2 = new TestClient(sn);

TestClient t3 = new TestClient(sn);

t1.start();

t2.start();

t3.start();

}

private static class TestClient extends Thread

{

private SequenceNumber sn;

public TestClient(SequenceNumber sn) {

this.sn = sn;

}

public void run()

{

for (int i = 0; i < 3; i++) {④每个线程打出3个序列值

System.out.println("thread["+Thread.currentThread().getName()+

"] sn["+sn.getNextNum()+"]");

}

}

}

}

通常我们通过匿名内部类的方式定义ThreadLocal的子类，提供初始的变量值，如例子中①处所示。TestClient线程产生一组序列号，在③处，我们生成3个TestClient，它们共享同一个SequenceNumber实例。运行以上代码，在控制台上输出以下的结果：

thread[Thread-2] sn[1]

thread[Thread-0] sn[1]

thread[Thread-1] sn[1]

thread[Thread-2] sn[2]

thread[Thread-0] sn[2]

thread[Thread-1] sn[2]

thread[Thread-2] sn[3]

thread[Thread-0] sn[3]

thread[Thread-1] sn[3]

  小结

      ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。
      在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。