Java并发编程笔记—基础知识—实用案例

如何正确停止一个线程

1）共享变量的使用

中断线程最好的，最受推荐的方式是，使用共享变量（shared variable）发出信号，告诉线程必须停止正在运行的任务。线程必须周期性的核查这一变量（尤其在冗余操作期间），然后有秩序地中止任务。当线程等待某些事件发生而被阻塞，又会发生什么？果线程被阻塞，它便不能核查共享变量，也就不能停止。这在许多情况下会发生，例如调用Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时。

 

2）Thread.interrupt()的理解

Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。

 

正确的停止线程方式是设置共享变量，并调用interrupt()（注意变量应该先设置）。如果线程没有被阻塞，这时调用interrupt()将不起作用；否则，线程就将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。在任何一种情况中，最后线程都将检查共享变量然后再停止。 

实例如下：

package com.iflytek.ossp.bliserver.common.utils;



public abstract class MyWorkRunnable implements Runnable {

    volatile Thread mTheThread = null;



    @Override

    public void run() {

        if (mTheThread != Thread.currentThread()) {

            throw new RuntimeException();

        }



        while (!Thread.interrupted() && mTheThread != null) {

            execute();

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

                mTheThread.interrupt();

            }

        }

    }



    public void start() {

        mTheThread = new Thread(this);

        mTheThread.start();

    }



    public void stop() {

        if (mTheThread != null) {

            mTheThread.interrupt();

            try {

                mTheThread.join(); // 等待线程彻底结束

            } catch (InterruptedException e) {

                e.printStackTrace();

                mTheThread.interrupt();

            }

        }

    }



    public abstract void execute();

}

  

在现有的线程安全类中添加功能

假设有一个线性的链表，需要提供一个原子的“若没有则添加”的操作。

第一种方法：扩展现有的类

public class BetterVector<E> extends Vector<E> {



    public synchronized boolean putIfAbsent(E x) {

        boolean absent = !contains(x);

        if (absent)

            add(x);

        return absent;



    }

}

第二种方法：客户端加锁

注意下面这张方法是不能实现线程安全的。

public class ListHelper<E> {



    public List<E> list = Collections.synchronizedList(new ArrayList<E>());



    public synchronized boolean putIfAbsent(E x) {

        boolean absent = !list.contains(x);

        if (absent)

            list.add(x);

        return absent;

    }



}

问题出在使用错误的锁进行同步，无论List使用哪一个锁来保护它的状态，可以确定的是这个锁并不是ListHelper上的锁。

正确的方式是是使用客户端加锁：

public class ListHelper<E> {



    public List<E> list = Collections.synchronizedList(new ArrayList<E>());



    public boolean putIfAbsent(E x) {

        synchronized (list) {

            boolean absent = !list.contains(x);

            if (absent)

                list.add(x);

            return absent;

        }

    }

}

但这张方法是脆弱的，因为需要依赖List的加锁策略，只有在遵循加锁策略上的类使用客户端加锁才有效。

最好的方式是使用组合：

public class ImprovedList<T> implements List<T> {



    private final List<T> list;



    public ImprovedList(List<T> list) {

        this.list = list;

    }



    public synchronized boolean putIfAbsent(T x) {

        boolean contains = !list.contains(x);

        if (contains)

            list.add(x);

        return contains;

    }



    public synchronized void clear() {

        list.clear();

    }



    // ......按照类似的方式委托list的其他方法。

}

  

ThreadLocal的使用

下面是一个使用ThreadLocal来记录线程中各个方位调用耗时的帮助类。

import java.util.Date;

import java.util.HashMap;

import java.util.Map;



/**

 * 用于跟踪各个线程中方法调用的耗时等信息。

 * <p>

 * 对于一个线程串行多次执行同一个方法,只能跟踪到最后一次的执行信息。

 * 

 * @author jdzhan,2013-1-13

 * 

 */

public final class MethodCallTrace {



    private static final ThreadLocal<Map<String, TraceInfo>> mutilThreadTraces = new ThreadLocal<Map<String, TraceInfo>>() {

        @Override

        protected Map<String, TraceInfo> initialValue() {

            return new HashMap<String, TraceInfo>();

        }

    };



    /**

     * 开始跟踪

     */

    public static void start() {

        String funcName = new Throwable().getStackTrace()[1].getMethodName();

        start(funcName);

    }



    /**

     * 结束跟踪

     */

    public static void end() {

        String funcName = new Throwable().getStackTrace()[1].getMethodName();

        end(funcName);

    }



    /**

     * 开始跟踪

     * 

     * @param funcName

     *            指定一个方法名称

     */

    public static void start(String funcName) {



        TraceInfo item = new TraceInfo();

        item.setStartTime(new Date());



        Map<String, TraceInfo> traces = null;

        if (mutilThreadTraces.get() == null) {

            traces = new HashMap<String, TraceInfo>();

            mutilThreadTraces.set(traces);

        } else {

            traces = mutilThreadTraces.get();

        }



        traces.put(funcName, item);

    }



    /**

     * 结束跟踪

     * 

     * @param funcName

     *            指定一个方法名

     */

    public static void end(String funcName) {

        Map<String, TraceInfo> traces = mutilThreadTraces.get();

        if (traces == null) {

            return;

        }

        TraceInfo item = traces.get(funcName);

        if (item == null) {

            return;

        }

        item.setEndTime(new Date());

    }



    public static Map<String, TraceInfo> getTrace() {

        return mutilThreadTraces.get();

    }

}

MethodCallTrace

import java.util.Date;



public class TraceInfo {



    private Date startTime;

    private Date endTime;



    public Date getStartTime() {

        return new Date(startTime.getTime());

    }



    public void setStartTime(Date startTime) {

        this.startTime = new Date(startTime.getTime());

    }



    public Date getEndTime() {

        return new Date(endTime.getTime());

    }



    public void setEndTime(Date endTime) {

        this.endTime = new Date(endTime.getTime());

    }



    /**

     * 获取方法调用的耗时，如果返回-1或小于0说明记录存在问题。

     * 

     * @return

     */

    public long getCallTime() {

        if (startTime == null || endTime == null) {

            return -1;

        }

        return endTime.getTime() - startTime.getTime();

    }

}

TraceInfo

import java.util.Map;

import java.util.Map.Entry;



public class ThreadLocalTest {



    /**

     * @param args

     */

    public static void main(String[] args) {

        MethodCallTrace.start();

        for (int i = 0; i < 3; i++) {

            new Thread(new Runnable() {



                @Override

                public void run() {

                    test();

                    test2();

                    test3();

                    Map<String, TraceInfo> trace = MethodCallTrace.getTrace();



                    for (Entry<String, TraceInfo> entry : trace.entrySet()) {

                        System.out.println(Thread.currentThread().getId() + entry.getKey() + ":" + entry.getValue().getCallTime() + "毫秒");

                    }

                }

            }).start();

        }

        

        while (true) {

            try {

                Thread.sleep(3000);

                MethodCallTrace.end();

                Map<String, TraceInfo> trace = MethodCallTrace.getTrace();

                for (Entry<String, TraceInfo> entry : trace.entrySet()) {

                    System.out.println("主线程：" + entry.getKey() + ":" + entry.getValue().getCallTime() + "毫秒");

                }

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

    }



    private static void test() {

        MethodCallTrace.start();

        for (int i = 0; i < 1; i++) {

            try {

                Thread.sleep(Thread.currentThread().getId());

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

        MethodCallTrace.end();

    }



    private static void test2() {

        MethodCallTrace.start("test2");

        for (int i = 0; i < 10; i++) {

            try {

                Thread.sleep(Thread.currentThread().getId());

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

        MethodCallTrace.end("test2");

    }



    private static void test3() {

        MethodCallTrace.start("test3");

        for (int i = 0; i < 10; i++) {

            try {

                Thread.sleep(Thread.currentThread().getId());

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

        MethodCallTrace.end("test3");

    }

}

待补充……