浅谈Java多线程（一）

Java支持多线程，可以通过继续Thread类或实现Runnable接口定义线程类，并在该类中重写run方法。
一个简单的Java线程类MyThread如下所示。
package com.wt.testThread;

public class MyThread extends Thread{
    public void run()
    {
        int i = 0;
        while (true)
        {
            i++;
            System.out.println("MyThread Processing --> "+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {}
        }
    }

    public static void main(String args[])
    {
        MyThread thread = new MyThread();
        thread.start();
    }
}
在MyThread的run方法中，每隔500ms（Thread.sleep(500);）输出一次信息。在主函数中，新建MyThread实例对象，并使用对象的start方法启动该线程实例。程序输出结果部分如下所示。
MyThread Processing --> 1
MyThread Processing --> 2
MyThread Processing --> 3
……

多线程的同步
假设现在有两件工具，三个工人，每个工人工作时需要同时使用这两件工具。使用Java多线程模拟上述情景，使用线程类WorkThread表示工人，使用ToolBox表示两件工具所在的工具箱，如下所示。
class ToolBox{
    //t1Owner,t2Owner分别表示正在使用该工具的工人名
    private String t1Owner;
    private String t2Owner;

    //useTool表示某位工人取得工具并使用
    public void useTool(String workerName) throws InterruptedException
    {
        t1Owner = workerName;
        Thread.sleep(100);
        t2Owner = workerName;
        Thread.sleep(100);
        checkTool();
    }

    //useTool检查工具是否正在被同一个工人使用
    public void checkTool()
    {
        if (!t1Owner.equals(t2Owner)){
            System.out.println("*Wrong*： Tool1:"+t1Owner+"\t Tool2:"+t2Owner);
        }
        else{
            System.out.println("*Right*: Tool1:"+t1Owner+"\t Tool2:"+t2Owner);
        }
    }
}

public class WorkerThread extends Thread{
    private ToolBox toolBox;
    private String workerName;

    public WorkerThread(String workerName,ToolBox toolBox)
    {
        super();
        this.workerName = workerName;
        this.toolBox = toolBox;
    }

    public void run()
    {
        //工人每次休息1秒，然后使用工具工作
        while(true)
        {
            try {
                Thread.sleep(1000);
                toolBox.useTool(workerName);
            } catch (InterruptedException e) {}
        }
    }
}
主函数如下所示，其中ToolBox类实例toolBox表示工人共用的工具箱，通过WorkerThread类的构造函数构造三个工人线程类，并传入工人姓名和toolBox，启动线程。
public static void main(String args[])
{
    //工人共用的工具箱
    ToolBox toolBox = new ToolBox();
    //三个工人开始工作
    new WorkerThread("Tom",toolBox).start();
    new WorkerThread("Jack",toolBox).start();
    new WorkerThread("Bob",toolBox).start();
}
执行结果部分如下所示。
*Right*: Tool1:Bob   Tool2:Bob
*Right*: Tool1:Bob   Tool2:Bob
*Wrong*: Tool1:Bob   Tool2:Jack
*Wrong*: Tool1:Bob   Tool2:Jack
*Wrong*: Tool1:Bob   Tool2:Jack
*Right*: Tool1:Jack Tool2:Jack
*Right*: Tool1:Jack Tool2:Jack
*Right*: Tool1:Jack Tool2:Jack
*Wrong*: Tool1:Jack Tool2:Tom
*Wrong*: Tool1:Jack Tool2:Tom
*Wrong*: Tool1:Jack Tool2:Tom
*Right*: Tool1:Tom   Tool2:Tom
可以看出，由于三个工人线程类共享使用工具箱中的工具，导致存在对于工具使用的竞争。由于ToolBox中useTool方法的代码（即工人使用工具）存在上述多线程之间的资源竞争，因此将其称为临界区（Critical Section）。临界区如下所示。
t1Owner = workerName;
Thread.sleep(100);
t2Owner = workerName;
Thread.sleep(100);
checkTool();
对于上述临界区中的代码，需要实现同步，即在一个线程中，要么都执行，要么都不执行。在Java中，可以使用关键字synchronized实现同步。synchronized的使用方法有两种：
1）对于需要同步的共享实例对象，将synchronized添加为方法的修饰符，如下所示。
public synchronized void useTool(String workerName) throws InterruptedException
2）将需要同步的临界区代码放入synchronized(this){}中，如下所示。
synchronized(this)
{
    t1Owner = workerName;
    Thread.sleep(100);
    t2Owner = workerName;
    Thread.sleep(100);
    checkTool();
}   www.zzzyk.com
使用synchronized同步后，重新执行原主函数，得到正确执行结果。
*Right*: Tool1:Tom   Tool2:Tom
*Right*: Tool1:Bob   Tool2:Bob
*Right*: Tool1:Jack Tool2:Jack
*Right*: Tool1:Tom   Tool2:Tom
*Right*: Tool1:Bob   Tool2:Bob
*Right*: Tool1:Jack Tool2:Jack
*Right*: Tool1:Tom   Tool2:Tom
*Right*: T

补充：软件开发 , Java ,