JAVA多线程机制

参考<<疯狂JAVA讲义>> 第16章节,还可以参考sina博文 "JAVA多线程相关介绍"

多线程概述
个人觉得这方面已经有很多资料介绍了，不过还是觉得 <<疯狂JAVA讲义>>线程概述还是挺透彻，明了的

2种方式创建线程，一种是extends Thread,一种是implements Runnable
这里需要注意的是Runnable对象仅仅是作为Thread对象的target，Runnable的run方法作为仅是线程执行体

线程的生命周期(这里疯狂JAVA讲义在这块讲的很好)

和线程控制有关的方法：
start():新建的线程进入Runnable状态.
run():线程进入Running状态(不要直接在程序中调用线程的run方法，是由系统调用的)。
wait():线程进入等待状态，等待被notify，这是对象方法，而不是线程方法
notify()/notifyAll():唤醒其他线程，这是对象方法，而不是线程方法
yield():线程放弃执行，使其他优先级不低于该线程的线程有机会运行，是静态方法
getPriority()/setPriority():设置线程优先级
sleep():线程睡眠一段时间
join():调用这个方法的主线程，会等待加入的子线程完成。

多线程同步
A:关键字synchronized 来与对象的互斥锁联系
1)synchronized关键字可以修饰代码块，方法，但是不可以修饰构造器，属性等。
2)特别指出的是synchronized锁定的不是方法或代码块，而是对象。当synchronized作为方法的修饰符时，它所取得的对象锁将被转交给方法的调用者；
当synchronized修饰的是对象时，则取得的对象锁将被转交给该引用指向的对象。Synchronized也可以修改类，表示这个类的所有方法都是Synchronized的
3)释放同步监视器(synchronized)的锁定:
当线程执行到synchronized()块结束时，释放对象锁
当在synchronized()块中遇到break, return或抛出exception，则自动释放对象锁
当一个线程调用wait()方法时，它放弃拥有的对象锁并进入blocked 状态

public class SuperTest 
{
    public static void main(String[] str)
    {
        Counter ct = new Counter();
        C1 c1 = new C1(ct, " c1 ");
        C1 c2 = new C1(ct, " c2 ");
        
        //启动2个子线程
        c2.start();
        c1.start();
        
        try {
            c2.join();
            c1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println(ct.getCount());
    }
}
    class Counter {
        private int count = 1000;

        protected int getCount() {
            return count;
        }

        protected void setCount(int count) {
            this.count = count;
        }
    }

    class C1 extends Thread {
        private Counter counter;

        private String sname;

        public C1(Counter cc, String s1) {
            this.counter = cc;
            this.sname = s1;
        }

        public Counter getCounter() {
            return counter;
        }

        public void setCounter(Counter counter) {
            this.counter = counter;
        }

        public String getSname() {
            return sname;
        }

        public void setSname(String sname) {
            this.sname = sname;
        }

        public void run() {
            for (int j = 0; j < 100; j++) {
                synchronized (counter){
                int i = counter.getCount();
                System.out.println(sname + j +  " before " + i);
                //System.out.println("now in :" + sname + " count = " + i);
                
                AddCounter(i - 1);
                    System.out.println(sname + j +  " after " + counter.getCount());
                }
            }
        }
        
        public void AddCounter(int i) {
            counter.setCount(i);
        }
    }
    

 

B:同步锁Lock

public class TestDraw
{
    public static void main(String[] args) 
    {
        //创建一个账户
        Account acct = new Account("1234567" , 1000);
        //模拟两个线程对同一个账户取钱
        new DrawThread("甲" , acct , 800).start();
        new DrawThread("乙" , acct , 800).start();
    }
}

public class DrawThread extends Thread
{
    //模拟用户账户
    private Account account;
    //当前取钱线程所希望取的钱数
    private double drawAmount;

    public DrawThread(String name , Account account , 
        double drawAmount)
    {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }

    //当多条线程修改同一个共享数据时，将涉及到数据安全问题。
    public void run()
    {
        account.draw(drawAmount);
    }
}

public class Account
{
    //定义锁对象
    private final ReentrantLock lock = new ReentrantLock();
    private String accountNo;
    private double balance;


    public Account(){}

    public Account(String accountNo , double balance)
    {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public void setAccountNo(String accountNo)
    {
        this.accountNo = accountNo;
    }
    public String getAccountNo()
    {
         return this.accountNo;
    }

    public double getBalance()
    {
         return this.balance;
    }
    public void draw(double drawAmount)
    {
        lock.lock();
        try
        {
            //账户余额大于取钱数目
            if (balance >= drawAmount)
            {
                //吐出钞票
                System.out.println(Thread.currentThread().getName() + 
                    "取钱成功！吐出钞票:" + drawAmount);
                try
                {
                    Thread.sleep(1);            
                }
                catch (InterruptedException ex)
                {
                    ex.printStackTrace();
                }
                //修改余额
                balance -= drawAmount;
                System.out.println("\t余额为: " + balance);
            }
            else
            {
                System.out.println(Thread.currentThread().getName() +
                    "取钱失败！余额不足！");
            }            
        }
        finally
        {
            lock.unlock();
        }
    }

    public int hashCode()
    {
        return accountNo.hashCode();
    }
    public boolean equals(Object obj)
    {
        if (obj != null && obj.getClass() == Account.class)
        {
            Account target = (Account)obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }
}

 

线程通信
(1) 线程的协调运行
wait(),notify(),notifyAll().这3个方法是Object类的方法，而不是Thread的方法,而且这3个方法必须由同步监视器(synchronized)对象来调用,2种情况:
1.synchronized修饰同步方法，因为该类默认实例(this)就是同步监视器，所以可以在同步方法中直接调用这3个方法
2.synchronized修饰同步代码块,同步监视器是synchronized括号中的对象，所以必须使用该对象调用这3个方法

wait()方法:
1. wait()方法是Object对象的方法，而不是Thread的方法
2. wait()方法只可能在synchronized块中被调用
3. wait()被调用时，原来的锁对象打开锁，线程进入blocked状态
4. wait()时间到期或被notify()唤醒的线程从wait()后面的代码开始继续执行
5. wait()和sleep()的主要区别是wait()会释放对象锁，而sleep()不会。

notify()和notifyAll()：
1．只能在synchronized中被调用
2．notify它会唤起同一个锁对象上的一个等待线程.但如果有几个线程在等待列表中，它无法决定是哪一个线程被唤醒。所以，为了防止不该唤醒的线程被唤醒，应该调用notifyAll,让所有的等待线程都有机会运行。

public class SuperTest 
{
    public static void main(String[] str)
    {
        Counter ct = new Counter();
        C2 c2 = new C2(ct, " c2 ");
        C1 c1 = new C1(ct, " c1 ");
        C2 c3 = new C2(ct, " c3 ");
        C1 c4 = new C1(ct, " c4 ");
        c3.start();
        c4.start();
        c2.start();
        c1.start();
        try {
            c2.join();
            c1.join();
            c3.join();
            c4.join();

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(ct.getCount());
    }
}

class Counter {
    private int count = 1000;

    public   int getCount() {
        return count;
    }

    public  void setCount(int count) {
        this.count = count;
    }
    
    public synchronized void addCounter(int j,String sname) {
        while (this.getCount() > 1007){
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
                
        int i = this.getCount();
        System.out.println(sname + j +  " before " + i);
        //System.out.println("now in :" + sname + " count = " + i);
        
        this.setCount(i+1);
        this.notifyAll();
        System.out.println(sname + j +  " after " + this.getCount());
    }    
    
    public synchronized void delCounter(int j,String sname) {
        while (this.getCount() < 990){
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
                
        int i = this.getCount();
        System.out.println(sname + j +  " before " + i);
        //System.out.println("now in :" + sname + " count = " + i);
        this.setCount(i - 1);
        this.notifyAll();
        System.out.println(sname + j +  " after " + this.getCount());
    }    
}

class C1 extends Thread {
    private Counter counter;

    private String sname;

    public C1(Counter cc, String s1) {
        this.counter = cc;
        this.sname = s1;
    }

    public Counter getCounter() {
        return counter;
    }

    public void setCounter(Counter counter) {
        this.counter = counter;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public void run() {
        for (int j = 0; j < 100; j++) {
            /*synchronized (counter){
            delCounter(j);
            }
            */
            counter.delCounter(j,sname);
        }
    }
}

class C2 extends Thread {
    private Counter counter;
    private String sname;
    
    public C2(Counter cc, String s1) {
        this.counter = cc;
        this.sname = s1;
    }

    public Counter getCounter() {
        return counter;
    }

    public void setCounter(Counter counter) {
        this.counter = counter;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public void run() {
        for (int j = 0; j < 100; j++) {
            /*
            synchronized (counter) {
            addCounter(j);
            }
            */
            if (j % 19 == 0) 
            { 
                try {
                        sleep(0,100);
                    } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                    }
            }
            
            counter.addCounter(j,sname);
        }
    }
}

这里使用的while作为判断语句，而不是if，这就是多线程中的“旋锁spin lock”的概念。这样可以避免用if带来的问题(仔细想想)，是这样的，我们在一个线程被唤醒时候要重新检测它的等待条件，一般用旋锁来实现。

我们可以和以前我们做项目用的UDI的线程处理来做对比，以前我们要保证共享数据操作的完整性，实现数据的同步时需要我们自己创建互斥量CSUDIOSMutexCreate，然后自己主动调用CSUDIOSMutexWait和CSUDIOSMutexRelease等待和释放互斥量来实现，而JAVA直接使用synchronized来实现了UDI互斥量类似的功能。
JAVA来用wait,notify,notifyAll来实现线程之间的通信，我们以前一般没有类似的线程通信，有一个比较类似的做法，比如要我们要结束某个线程，一般都是定义一个全局变量，修改其FLAG，然后调用CSUDIOSThreadJoin等待其结束，而在实际的线程函数中一般会用一个while循环不断检测该全局变量的flag,以便可以及时结束线程。

(2) 使用条件变量控制协调
如果程序不使用synchronized来保存同步，而是直接使用Lock对象来保证同步，那么系统中不存在隐式的同步监视器对象，也就不能使用
wait(),notify(),notifyAll()实现同步了，那么我们可以利用条件变量Condition来实现。

public class Account
{
    //显示定义Lock对象
    private final Lock lock = new ReentrantLock();
    //获得指定Lock对象对应的条件变量
    private final Condition cond  = lock.newCondition(); 

    private String accountNo;
    private double balance;

    //标识账户中是否已经存款的旗标
    private boolean flag = false;

    public Account(){}

    public Account(String accountNo , double balance)
    {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public void setAccountNo(String accountNo)
    {
        this.accountNo = accountNo;
    }
    public String getAccountNo()
    {
         return this.accountNo;
    }

    public double getBalance()
    {
         return this.balance;
    }
    public void draw(double drawAmount)
    {
        //加锁
        lock.lock();
        try
        {
            //如果账户中还没有存入存款，该线程等待
            if (!flag)
            {
                cond.await();
            }
            else
            {
                //执行取钱操作
                System.out.println(Thread.currentThread().getName() + 
                    " 取钱:" +  drawAmount);
                balance -= drawAmount;
                System.out.println("账户余额为：" + balance);
                //将标识是否成功存入存款的旗标设为false
                flag = false;
                //唤醒该Lock对象对应的其他线程
                cond.signalAll();
            }
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
        //使用finally块来确保释放锁
        finally
        {
            lock.unlock();
        }
    }
    public void deposit(double depositAmount)
    {
        lock.lock();
        try
        {
            //如果账户中已经存入了存款，该线程等待
            if(flag)
            {
                cond.await();                
            }
            else
            {
                //执行存款操作
                System.out.println(Thread.currentThread().getName() + 
                    " 存款:" +  depositAmount);
                balance += depositAmount;
                System.out.println("账户余额为：" + balance);
                //将标识是否成功存入存款的旗标设为true
                flag = true;
                //唤醒该Lock对象对应的其他线程
                cond.signalAll();
            }
        }
        catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
        //使用finally块来确保释放锁
        finally
        {
            lock.unlock();
        }
    }

    public int hashCode()
    {
        return accountNo.hashCode();
    }
    public boolean equals(Object obj)
    {
        if (obj != null && obj.getClass() == Account.class)
        {
            Account target = (Account)obj;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }
}

 

(3) 使用管道流
管道流的3种存在形式:
PipedInputStream和PipedOutputStream,PipedReader和PipedWriter,Pipe.SinkChannel和Pipe.SourceChannel

通常没有必要使用管道流来控制2个线程间通信，因为2个线程属于同一个进程，它们可以非常方便的共享数据，不必用管流

class ReaderThread extends Thread
{
    private PipedReader pr;
    //用于包装管道流的BufferReader对象
    private BufferedReader br;
    public ReaderThread(){}
    public ReaderThread(PipedReader pr)
    {
        this.pr = pr;
        this.br = new BufferedReader(pr);
    }
    public void run()
    {
        String buf = null;
        try
        {
            //逐行读取管道输入流中的内容
            while ((buf = br.readLine()) != null)
            {
                System.out.println(buf);
            }
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
        //使用finally块来关闭输入流
        finally
        {
            try
            {
                if (br != null)
                {
                    br.close();
                }
            }
            catch (IOException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}
class WriterThread extends Thread
{
    String[] books = new String[]
    {
        "Struts2权威指南",
        "ROR敏捷开发指南",
        "基于J2EE的Ajax宝典",
        "轻量级J2EE企业应用指南"
    };
    private PipedWriter pw;
    public WriterThread(){}
    public WriterThread(PipedWriter pw)
    {
        this.pw = pw;
    }
    public void run()
    {
        try
        {
            //循环100次，向管道输出流中写入100个字符串
            for (int i = 0; i < 100 ; i++)
            {
                pw.write(books[i % 4] + "\n");
            }
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
        //使用finally块来关闭管道输出流
        finally
        {
            try
            {
                if (pw != null)
                {
                    pw.close();
                }
            }
            catch (IOException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}

public class PipedCommunicationTest
{
    public static void main(String[] args)
    {
        PipedWriter pw = null;
        PipedReader pr = null;
        try
        {
            //分别创建两个独立的管道输出流、输入流
            pw = new PipedWriter();
            pr = new PipedReader();
            //连接管道输出流、出入流
            pw.connect(pr);

            //将连接好的管道流分别传入2个线程，
            //就可以让两个线程通过管道流进行通信
            new WriterThread(pw).start();
            new ReaderThread(pr).start();
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
    }
}

 

JAVA线程池:(参考疯狂JAVA编程对线程池的介绍)

为什么要用线程池:
1）减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务 2）可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的内存，
而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)

几个重要的类:
ExecutorService：真正的线程池接口。
ScheduledExecutorService: 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。
ThreadPoolExecutor: ExecutorService的默认实现。
ScheduledThreadPoolExecutor: 继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。

Executors类里面提供了一些静态工厂，生成一些常用的线程池。
newSingleThreadExecutor：
创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。
如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

newFixedThreadPool：
创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

newCachedThreadPool：
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，
当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，
线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

newScheduledThreadPool：
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

newSingleThreadExecutor：
创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

那我个人感觉就是new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, KEEPALIVE_TIME, TIME_UNIT, workQueue, rejectedExecutionHandler)；
提供了更定制化的线程池制造方法。因为newFixedThreadPool方法其实也是return new ThreadPoolExecutor

例子一:

//实现Runnable接口来定义一个简单的
class TestThread implements Runnable
{
    public void run()
    {
        for (int i = 0; i < 100 ; i++ )
        {
            System.out.println(Thread.currentThread().getName()
                + "的i值为:" + i);
        }
    }
}

public class ThreadPoolTest
{
    public static void main(String[] args) 
    {
        //创建一个具有固定线程数（6）的线程池
        ExecutorService pool = Executors.newFixedThreadPool(6);
        //向线程池中提交2个线程
        pool.submit(new TestThread());
        pool.submit(new TestThread());
        //关闭线程池
        pool.shutdown();
    }
}

例子二:

public class ThreadPoolTask implements Runnable { 
  // 保存任务所需要的数据 
  private Object threadPoolTaskData; 
  private static int consumeTaskSleepTime = 2000; 

  ThreadPoolTask(Object tasks) { 
    this.threadPoolTaskData = tasks; 
  } 

  public void run() { 
    // 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句 
    System.out.println("start .." + threadPoolTaskData); 
    try { 
      //便于观察，等待一段时间 
      Thread.sleep(consumeTaskSleepTime); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    threadPoolTaskData = null; 
  } 

  public Object getTask() { 
    return this.threadPoolTaskData; 
  } 
} 

public class ThreadPool { 
  private static int produceTaskSleepTime = 2; 
  private static int consumeTaskSleepTime = 2000; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.DiscardOldestPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        // 产生一个任务，并将其加入到线程池 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(produceTaskSleepTime); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

 

多线程的一般规则：
1. 如果2个或以上的线程都修改一个对象，那么把执行修改的方法定义为同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。
2. 如果一个线程必须等待一个对象的状态发生变化，那么它应该在对象内部等待，而不是在外部。它可以调用一个被同步的方法，并让这个方法调用wait()
3. 每当一个方法返回某个对象的锁时，它应该调用notify()/notifyAll()来让等待中的其他线程有机会调用。
4. 有wait()在的地方必须相应的有notify/notifyAll方法，且他们都作用于同一对象
5. 针对wait/notify/notifyAll使用旋锁(spin lock)
6. 优先使用notifyAll,而不是notify
7. 按照固定的顺序获取对象锁，以免死锁
8. 不要对上锁的对象改变他的引用
9. 不要滥用同步机制，避免无谓的同步控制