谈谈多线程

前言：

　　一直以来，对于多线程的理解总是赶在前一秒翻书时回忆起，后一秒放下书即忘。甚是可恼！今晚对多线程总结一下，也好有个了断~

概念引入：

　　首先，我们想了解的是：什么是线程，跟进程有什么关联？

　　其实是这样的：线程是程序执行流的最小单元。其一般有3种状态：就绪，执行和阻塞（因本文注重实例，就不对概念作过多的解释~）。在计算机中，一个代码块（block）运行时产生一个或多个进程（process）,而每一个进程又对应一至多个线程(thread)，每一个线程又可以分为一至多个任务（task）.

　　因此，以上的关系我们可以通过下面一张图进行理解。

• 1.创建线程的两种实现方式：

1）继承Thread类

2）实现Runnable接口

package com.gdufe.thread;

public class ThreadTest {

    public static void main(String[] args) {

        Thread thread1 = new Thread(new TaskA(),"thread1");
        Thread thread2 = new Thread(new TaskB('a',100),"thread2");
        Thread thread3 = new Thread(new TaskB('b',100),"thread3");
        
        thread1.start();;
        thread2.start();
        thread3.start();
        System.out.println("--End--");
        
        
    }
    
    /*
     * 任务A通过实现Runnable接口创建任务
     */
    private static class TaskA implements Runnable{

        @Override
        public void run() {
            for(int i=0;i<100;i++){
                System.out.print(i+" ");
            }
        }
        
    }
    /*
     * 任务B通过继承Thread类并重写run()方法来创建任务
     */
    private static class TaskB extends Thread{
        
        private char ch;
        private int times;
        
        public TaskB(char ch,int times){
            this.ch=ch;
            this.times=times;
        }
        @Override
        public void run() {
            for(int i=0;i<times;i++){
                System.out.print(ch+" ");
            }
        }
    }
}

输出结果：

• 2.线程池thread-pool 

　　线程池指的是不需要每个任务用一个线程来存储，而是初始就给出一个“池”。线程池首先会初始池的大小，即可供同时进入的“任务”的数量，这样的话每当来一个新任务就直接往线程池里面扔，不需要再单独创建一个个线程。

• 3.线程不安全

【不安全实例代码】

package com.gdufe.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadNotSafe {
    static Account account = new Account();

    public static void main(String[] args) {

        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            executor.execute(new Deposit());
        }
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finally, the account get the total balance:"
                + account.getBalance());
    }
    /*
     * 存钱操作，每次存入1
     */
    static class Deposit implements Runnable {

        @Override
        public void run() {
            account.deposit(1);
        }
    }

    static class Account {
        private int balance = 0;

        public int getBalance() {
            return balance;
        }

        public void deposit(int value) {
            int newBalance = balance + value;
            try {
                Thread.sleep(5);    //故意将原有的简单操作拆分两步，并且中间延迟5毫秒
            } catch (Exception e) {
            }
            balance = newBalance;
        }
    }

}

输出结果：

Finally, the account get the total balance:3

（注意：执行多次的结果不一样）

分析：

　　上述实例进行100个任务，每个任务都是往账号里面存“1”，正确的结果应该输出“100”，那为什么最终的结果好像“不正确”。原因是，当多个任务同时访问一个资源时，就出现了所谓的资源“竞争”。

解决方法：

1）使用关键字“synchronized”对资源进行封锁，此方式称作“隐式加锁”；

2）采用java内部工具类“Lock”进行“显式加锁”。

【方式1-代码修改部分】：

static class Account {
        private int balance = 0;

        public int getBalance() {
            return balance;
        }
        /*
         * 增加关键字‘synchronized’,方法未执行完时，仅限一个任务访问该方法
         */
        public synchronized void deposit(int value) {
            int newBalance = balance + value;
            try {
                Thread.sleep(5);    //故意延迟5毫秒
            } catch (Exception e) {
            }
            balance = newBalance;
        }
    }

【方式2-代码修改部分】：

static class Account {
        private int balance = 0;
        private static Lock lock = new ReentrantLock();

        public int getBalance() {
            return balance;
        }
        /*
         * 采用显示加锁，方法开始执行时加锁，执行结束前解锁
         */
        public void deposit(int value) {
            lock.lock();    //加锁
            int newBalance = balance + value;
            try {
                Thread.sleep(5);    //故意延迟5毫秒
                balance = newBalance;
            } catch (Exception e) {
            
            }finally{
                lock.unlock();     //解锁
            }
        }
    }

输出结果：

Finally, the account get the total balance:100

（多次执行，输出结果总是100）

• 4.线程协作实例：

　　实例情境：

　　假如现在要对一个银行账号（Account）进行存(Deposit)取(Withdraw)钱操作。故确定了2个线程，这里的协作需要注意一点的是当银行账号的余额不足时，取钱操作必须等待。因此，除了前面设定的锁之外，我们还得加一个信号量signal。信号量的作用是当取钱的数量大于当前账号余额时，停止该操作，发出等待的信号量signal；存钱时，有多少即存多少就是了。不过，每进行一次存钱操作，都必须发出信号提醒还在等待的取钱操作，不然取钱操作将一直等下去...

代码实现：

package com.gdufe.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadCooperation {
    private static Account account = new Account();

    public static void main(String[] args) {
        //开启大小为2线程池的，依次加入任务
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new DepositTask());
        executor.execute(new WithdrawTask());
        //关闭线程池入口
        executor.shutdown();
        System.out.println("Operation------Balance");
    }
    //从账号取出钱
    static class WithdrawTask implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    account.withdraw((int) (Math.random() * 10));
                }
            } catch (Exception e) {
            }
        }
    }
    //往账号存钱
    static class DepositTask implements Runnable {
        @Override
        public void run() {
            try{
            while (true) {
                account.deposit((int) (Math.random() * 10));
                Thread.sleep(1000);
            }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    //内部类，只有‘balance’属性
    static class Account {
        private int balance = 0;
        private static Lock lock = new ReentrantLock();
        private static Condition signal = lock.newCondition();

        public int getBalance() {
            return balance;
        }
        //前后加锁，解锁
        public void deposit(int amount) {
            lock.lock();
            try {
                balance += amount;
                System.out.println("deposit "+amount+"----total:" + account.getBalance());
                signal.signalAll();        //not 'notifyAll()'
            } finally {
                lock.unlock();
            }
        }
        //同样加锁，解锁
        public void withdraw(int amount) {
            lock.lock();
            try {
                while (balance < amount) {
                    signal.await();
                    System.out.println("signal await...");
                }
                balance -= amount;
                System.out.println("whthdraw "+amount+"----total:" + account.getBalance());
            } catch (Exception e) {
                    e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

}

输出结果：

• 5.经典生产者消费者问题

（抱歉，时间关系！后续补上关于生产者消费者的实例，敬请关注~~）