Lesson11-Java多线程

最新推荐文章于 2024-09-21 10:38:43 发布

Ayin的学习笔记

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量195

点赞数

文章标签： java

本文链接：https://blog.csdn.net/AyinMars/article/details/119519516

版权

多线程

所谓程序，就是指令和数据的有序集合，其本省没有任何运行的含义，是一个静态的概念，而进程则是一次执行程序的过程，它是一个动态的概念，是系统资源分配的单位。

通常在一个进程中可以包含多个线程，当然，一个进程中至少有一个线程，不然就失去了存在的意义，线程是CPU调度和执行的单位。

需要注意的是：很多多线程都是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换地很快，所以就有了同时执行的错觉。

线程的核心概念：

线程就是独立的执行路径
在线程运行的时候，即使自己没有创建线程，后台也会有多个线程，如主线程，gc线程等
main()称为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统密切相关的，先后顺序是不能认为地干预的
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如CPU的调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

Thread

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
public class ThreadTest01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("Tset01-->" + i);
        }
    }
    public static void main(String[] args) {
        ThreadTest01 threadTest01 = new ThreadTest01();
        threadTest01.start();
//    threadTest01.run(); //优先启动该线程
        for (int i = 0; i < 200; i++) {
            System.out.println("Test02-->" + i);
        }
    }
}

注意：线程开启的时候不一定是立刻执行的，总的来说还是由CPU调度来执行。

在JDK提供的与文件相关的类，其功能都非常的基础，完成复杂的操作就需要做大量的编程工作。实际开发中往往需要开发大量的代码，而Apache-commons 工具包提供了相应的类来实现IO，我们通过这个工具包所提供的类，来实现一个多线程下载图片的例子。

下载：http://commons.apache.org/proper/commons-io/，然后选择最新版的download。

在这里插入图片描述
在Java项目src下新建lib目录，将下载好的commonsIO复制进去，然后右键add Build Path就可以使用了

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread，实现多线程下载图片
public class ThreadTest02 extends Thread {
    private String url;
    private String name;

    public ThreadTest02(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        WebPicturesDownload webPicturesDownload = new WebPicturesDownload();
        webPicturesDownload.download(url, name);
        System.out.println("下载了文件名为：" + name  + "的图片");
    }

    public static void main(String[] args) {
        ThreadTest02 t1 = new ThreadTest02("#", "Test01.jpg");
        ThreadTest02 t2 = new ThreadTest02("#", "Test02.jpg");
        ThreadTest02 t3 = new ThreadTest02("#", "Test03.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}
//下载器
class WebPicturesDownload  {
    public void download(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            System.out.println("IO异常");
        }
    }
}

Runnable

// 创建线程方式二：
// 创建类实现runnable接口，重写run()方法，执行线程需要丢入runnable接口实现类，调用start开启线程
public class RunnableTest01 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("Tset01-->" + i);
        }
    }
    public static void main(String[] args) {
        // 创建runnable接口的实现类对象
        RunnableTest01 r1 = new RunnableTest01();
        // 创建线程对象，通过线程对象来开启线程(代理)
        new Thread(r1).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("Test02-->" + i);
        }
    }
}

小结：

推荐使用实现Runnable接口来实现多线程，这是为了避免继承Thread类方式所导致的OOP单继承局限性，而实现Runnable接口的方式灵活方便，同一个对象可以被多个线程使用，避免了单线程局限性。

并发问题

并发问题是指在多个线程对同一个资源进行操作的时候，会出现数据重复、输出错误、甚至是数据紊乱的问题。举个例子，在多个人买火车票的情况下，并发问题是指数几个人买到了同一张票。

/**
 * 多人买火车票
 * 存在以下问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
 */
public class RunnableTest02 implements Runnable{
    private int tickNum = 10;
    @Override
    public void run() {
        while(true) {
            if (tickNum <= 0) {
                break;
            }
            // 线程延迟
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + tickNum + "张票");
            tickNum--;
        }
    }
    public static void main(String[] args) {
        RunnableTest02 r2 = new RunnableTest02();
        new Thread(r2, "小明").start();
        new Thread(r2, "黄牛").start();
        new Thread(r2, "Ayin").start();
    }
}

/**
 * 模拟龟兔赛跑问题
 */
public class Race implements Runnable {
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            // 模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && i == 50) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            boolean flag = gameOver(i);
            if (flag == true) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "米");
        }
    }
    // 判断游戏结束条件
    public boolean gameOver(int step) {
        // 存在胜利者，游戏结束
        if (winner != null) {
            return true;
        }
        // 跑完1000米，游戏结束
        if (step == 100) {
            winner = Thread.currentThread().getName();
            System.out.println("winner is " + winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

Callable

实现Callable接口，需要返回值类型
重写Call方法，需要抛出异常
创建目标对象
创建执行服务：
提交执行
获取结果
关闭服务

依旧是多线程下载图片的例子，相比起继承Thread类的方法，步骤更为繁琐，但重写的Call方法是具有返回值的，并且可以抛出异常供外部捕获，且支持泛型。

//线程创建方式三：实现Callable接口
public class CallableTest01 implements Callable<Boolean> {
    private String url;
    private String name;

    public CallableTest01(String url, String name) {
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() throws Exception {
        WebPicturesDownload webPicturesDownload = new WebPicturesDownload();
        webPicturesDownload.download(url, name);
        System.out.println("下载了文件名为：" + name + "的图片");
        return true;
    }
    public static void main(String[] args) {
        CallableTest01 c1 = new CallableTest01("#", "Test01.jpg");
        CallableTest01 c2 = new CallableTest01("#", "Test02.jpg");
        CallableTest01 c3 = new CallableTest01("#", "Test03.jpg");
        // 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        / /提交执行
        Future<Boolean> r1 = ser.submit(c1);
        Future<Boolean> r2 = ser.submit(c2);
        Future<Boolean> r3 = ser.submit(c3);
        // 获取结果
        try {
            Boolean rs1 = r1.get();
            Boolean rs2 = r2.get();
            Boolean rs3 = r3.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //关闭服务
        ser.shutdownNow();
    }
}

静态代理模式

真实对象和代理对象都要实现同一个接口，代理对象要代理真实角色，这样可以让真实对象专注执行自身的方法，而代理对象可以做到在不修改真实对象的功能前提下，对目标功能扩展。

需要注意的是,代理对象与目标对象要实现相同的接口,然后通过调用相同的方法来调用目标对象的方法

public class StaticProxyTest01 {
    public static void main(String[] args) {
        new WeddingCompany(new You()).HappyMarry();
    }
}
interface Marry {
    void HappyMarry();
}
//真实对象
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚进行时");
    }
}
//代理对象
class WeddingCompany implements Marry {
    private Marry target;
    public WeddingCompany(Marry target) {
        this.target = target;
    }
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry(); //真实对象调用本身方法
        after();
    }
    private void after() {
        System.out.println("结婚之后，收尾款");
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}

Lambda表达式

λ希腊字母表中排序第十一位的字母，英文名称为Lambda，引用该表达式的作用主要是避免匿名内部类定义过多，去掉了一堆没有意义的代码，只留下了核心的逻辑，不过，其实质是属于函数式编程的概念。

new Thread(() -> System.out.println("多线程学习...")).start();

学习Lambda表达式，就必须先要了解函数式接口！了解函数式接口在Lambda表达式中的关键所在！

函数式接口的定义：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口，对于函数式接口，我们可以通过Lambda表达式来创建该接口的对象。

interface ILike {	//函数式接口的前提条件是只包含唯一一个抽象方法！
    void lamdba();
}

//推导Lambda表达式
public class LambdaTest01 {
    //3.静态内部类
    static class Like2 implements ILike {
        @Override
        public void lamdba() {
            System.out.println("I like Lambda, 静态内部类!");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lamdba();
        like = new Like2(); //静态
        like.lamdba();

        //4.局部内部类
        class Like3 implements ILike {
            @Override
            public void lamdba() {
                System.out.println("I like Lambda, 局部内部类!");
            }
        }
        like = new Like3(); //局部
        like.lamdba();
        //5.匿名内部类（没有类的名称，必须借助接口或者父类）
        like = new ILike() {
            @Override
            public void lamdba() {
                System.out.println("I like Lambda, 匿名内部类!");
            }
        };
        like.lamdba();  //匿名
        //6.使用lambda简化(JDK8)
        like = () -> {
            System.out.println("I like Lambda, Lambda简化!");
        };
        like.lamdba();
    }
}
//1.接口类
interface ILike {
    void lamdba();
}
//2.实现类
class Like implements ILike {
    @Override
    public void lamdba() {
        System.out.println("I like Lambda!");
    }
}

public class LambdaTest02 {
    public static void main(String[] args) {
        // Lambda表达式简化
//        ILove love = (int a) -> {
//            System.out.println("I LOVE YOU, " + a);
//        };
        // 1. 简化返回值
//        ILove love = (a) -> {
//            System.out.println("I LOVE YOU, " + a);
//        };
        // 2.简化括号
//        ILove love = a -> {
//            System.out.println("I LOVE YOU, " + a);
//        };
        // 3. 简化花括号
        ILove love = a -> System.out.println("I LOVE YOU, " + a);   
        love.Love(520);
    }
}
interface ILove {
    void Love(int a);
}

Lambda表达式意义上还是简化代码，不过以上简化方法需要注意以下几点：

必须是函数式接口才能使用Lambda表达式
去掉花括号的前提是，只有一行代码的才可以简化成这样，否则还是需要使用代码块
有多个返回值的情况下，可以省去返回类型，但是不可以简化括号的

线程状态

在这里插入图片描述
处理线程状态的常用方法

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long millisecond)	在指定的毫秒数内让当前执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程(并不建议使用该方式)
boolean isAlive()	测试线程是否处于活动状态

线程停止

值得注意的是，现如今，停止线程已经不推荐使用JDK提供的stop()、destroy()方法，更推荐使线程自己停下来，建议使用一个标志位来进行终止变量，例如：当flag = false，则线程终止。

/**
 * 测试stop
 * 1. 建议线程正常停止--->利用次数，不建议死循环
 * 2. 建议使用标志位
 * 3. 不要使用stop或destroy等过时或JDK不建议使用的方法
 */
public class StopTest01 implements Runnable{
    private boolean flag;
    @Override
    public void run() {
        int i = 0;
        while (flag) {
            i++;
        }
    }
    private void stop() {
        this.flag = false;
    }
    public static void main(String[] args) {
        StopTest01 stopTest01 = new StopTest01();
        new Thread(stopTest01).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if (i == 900) {
                stopTest01.stop();
                System.out.println("线程该停止了！");
            }
        }
    }
}

线程休眠

要想线程在一段时间内停止执行，可以调用sleep方法来使线程进入线程阻塞状态，该方法是在指定的毫秒数内让当前执行的线程休眠，需要注意的有以下几点：

sleep(时间) 是指当前线程阻塞的毫秒数
sleep存在异常“interruptedException”
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延迟或者倒计时等等
每个对象都有一把锁，sleep不会释放锁

// 倒计时10秒
public class SleepTest02 implements Runnable {
    public static void main(String[] args) {
        SleepTest02 sleepTest02 = new SleepTest02();
        sleepTest02.run();
    }
    @Override
    public void run() {
        int number = 10;
        while(true) {
            System.out.println(number--);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (number <= 0) {
                break;
            }
        }
    }
}

// 当前时间计时
public class SleepTest03 {
    public static void main(String[] args) {
        Runnable r1 = () -> {
            Date startTime = new Date(System.currentTimeMillis()); // 获取当前系统时间
            while(true) {
                try {
                    Thread.sleep(1000);
                    System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));	// 时间格式化
                    startTime = new Date(System.currentTimeMillis()); // 刷新时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        r1.run();
    }
}

线程礼让

礼让线程，顾名思义，让当前正在运行的线程暂停，但不会进入阻塞状态！而是从运行状态转变为就绪状态！让CPU重新进行调度，不过礼让并不一定成功，纯属看CPU心情。

public class YieldTest01 {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield, "A").start();
        new Thread(myYield, "B").start();

    }
}
class MyYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行！");
        Thread.yield(); // 线程礼让（并不一定成功）
        System.out.println(Thread.currentThread().getName() + "线程停止执行！");
    }
}

线程强制执行

Join方法可以使当前线程强制执行，只有等到该线程执行完之后，其他线程才会继续运行，而该线程执行的时候，其他线程处于阻塞状态，可以理解为插队，是非常霸道的线程执行方式，并不推荐使用，容易造成线程堵塞。

public class JoinTest01 implements  Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("VIP线程正在执行！" + i);
        }
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(new JoinTest01());
        t1.start();
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                try {
                    t1.join();	// t1线程强制执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main线程执行中..." + i);
        }
    }
}

线程观测状态

Thread类提供的state方法可以查询当前线程的状态，大致为以下六种！

在这里插入图片描述

public class StateTest01 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000); //线程每秒睡一次
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread is running....");
            }
        });
        // 观测状态
        Thread.State state = thread.getState();
        System.out.println(state);  // NEW
        // 线程启动
        thread.start();
        state = thread.getState();
        System.out.println(state);  // RUNNING

        while(state != Thread.State.TERMINATED)  {  
        	// 当线程不处于终止状态时便不停输出当前线程状态
            try {
                Thread.sleep(100);  
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();
            System.out.println("Thread is" + state);
        }
    }
}

线程的优先级

Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，该线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数组表示，范围为[1, 10]。

可以使用getPriority方法和setPriority方法来改变或获取线程优先级。

需要注意的是：优先级低只是意味着获取调度的概率低，并不是优先级低就不会被调用，具体还是得要看CPU的调度，如果优先级低的线程比优先级高的线程先执行，一般称这种错误为性能倒置！

public class PriorityTest01 {
    public static void main(String[] args) {
        //主线程的默认优先级
        System.out.println(Thread.currentThread().getName() 
        + "--->" + Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority, "t1");
        Thread t2 = new Thread(myPriority, "t2");
        Thread t3 = new Thread(myPriority, "t3");
        Thread t4 = new Thread(myPriority, "t4");
        //必须先设置优先级，再启动！
        t1.setPriority(Thread.MAX_PRIORITY); // 最高优先级
        t2.setPriority(Thread.MIN_PRIORITY); // 最低优先级
        t3.setPriority(4);
        t4.setPriority(8);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
class MyPriority implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() 
        + "--->" + Thread.currentThread().getPriority());
    }
}

守护线程

线程也分为守护线程和用户线程，虚拟机必须确保用户线程执行完毕，但虚拟机不用等待守护线程(gc线程)执行完毕，例如：后台记录操作日志、监控内存、垃圾回收等待…

public class DaemonTest01 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new God());
        t1.setDaemon(true);
        t1.start();
        // 该方法默认为false，表示为用户线程，正常的线程都是用户线程
        new Thread(new MyDaemon()).start();
        //守护线程理应不会停止，但虚拟机并不需要等待守护线程运行完毕
    }
}
//用户线程
class MyDaemon implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("I am alive!");
        }
    }
}
//守护线程
class God implements Runnable {
    @Override
    public void run() {
        while(true) {
            System.out.println("God bless you!");
        }
    }
}

线程同步

处理多线程问题时，多个线程访问一个对象（并发），并且某些线程还想修改这个对象，这时候我们就需要线程同步。

线程同步，其实就是一种等待机制，多个需要同时访问此对象的线程进入到这个对象的等待池形成队列，等待前面线程执行完毕之后，才会轮到下一个线程继续执行。

由于同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为保证数据在方法中被访问时的正确性，于是就在访问时加入了锁机制（synchronized），当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可！但同样也会存在以下几种问题：

一个线程持有锁会导致其他所有需要此锁的线程挂起。
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延迟，引起性能问题。
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题！

线程三大不安全案例

第一个案例：买票

程序运行之后会出现xx购得第-1张票的结果，是因为票只剩下1张的时候，三条线程都认为票可以进行购买。

public class UnsafelyTicket implements Runnable {
    private int tickNum = 10;
    private boolean flag = true;
    @Override
    public void run() {
        while(flag) {
            Buy();
        }
    }
    public void Buy() {
        while(true) {
            if (tickNum <= 0) {
                flag = false;
                return;
            }
            //线程延迟
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() 
            + "拿到了第" + tickNum-- + "张票");
        }
    }    public static void main(String[] args) {
        UnsafelyTicket r2 = new UnsafelyTicket();
        new Thread(r2, "小明").start();
        new Thread(r2, "黄牛").start();
        new Thread(r2, "Ayin").start();
    }
}

第二个案例：银行取钱，当两个人同时往一个账户里取钱，而账户余额并不够，就会出现取完钱银行余额为负数的情况。

public class UnsafetyBank {
    public static void main(String[] args) {
        Account account = new Account(100, "建设银行卡");
        Drawing A = new Drawing(account, 50, "A");
        Drawing B = new Drawing(account, 100, "B");
        A.start();
        B.start();
    }
}
class Account {
    int money;  // 余额
    String name; // 卡名
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
class Drawing extends Thread {
    Account account; // 账户
    int drawMoney; // 取款数
    int nowMoney; // 手里的钱

    public Drawing(Account account, int drawMoney, String name) {
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;
    }
    @Override
    public void run() {
        if (account.money - drawMoney < 0) {
            System.out.println(getName() + "余额不足！");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额
        account.money = account.money - drawMoney;
        //手里的钱
        nowMoney = nowMoney + drawMoney;

        System.out.println(account.name + "余额为" + account.money);
        System.out.println(getName() + "手里的钱：" + nowMoney);
    }
}

第三个案例：线程不安全的集合，例如List，在执行add方法往集合里添加多个线程对象时，会出现有些线程对象并不能添加进去的情况。

public class UnsafetyList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
               list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

synchronized

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制来同步方法，这个机制就是synchronized关键字！

synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象锁才能执行，否则线程会堵塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被堵塞的线程才能获得这把锁，继续执行。

需要注意的是：若将一个大的方法声明为synchronized将会影响效率。

例如在三大不安全案例中的买票案例，可以在买票方法中添加synchronized关键字

private synchronized void Buy() {
    if (tickNum <= 0) {
        flag = false;
        return;
    }
    System.out.println(Thread.currentThread().getName() + "拿到了第" + tickNum-- + "张票");
}

需要注意的是，如果有多个线程进行，而要求只需要其中几个线程进行“排队”，那么，在synchronized代码块中，需要填入的一定是共享对象！也就是上述例子中的this！

// 银行账户取钱案例
public class SynchronizedBank {
    public static void main(String[] args) {
        UserAccount userAccount = new UserAccount("建设银行卡", 10000);
        Thread t1 = new AccountThread(userAccount);
        Thread t2 = new AccountThread(userAccount);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}
class UserAccount {
    private String actno;
    private int balance;
    public UserAccount() {
    }
    public UserAccount(String actno, int balance) {
        this.actno = actno;
        this.balance = balance;
    }
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public int getBalance() {
        return balance;
    }
    public void setBalance(int balance) {
        this.balance = balance;
    }
    public void withdraw(int money) {
        synchronized (this) {
            // 两个线程同时往一个账户里取钱，而这个账户便是共享对象(UserAccount)，也就是this！
            int before = this.getBalance();
            int after = before - money;
            // 模拟网络延迟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }
}
class AccountThread extends Thread {
    private UserAccount act;
    public AccountThread(UserAccount act) {
        this.act = act;
    }
    @Override
    public void run() {
    // 假设取款5000
    int money = 5000;
    act.withdraw(money);
    System.out.println(Thread.currentThread().getName() + 
    "对" + act.getActno() + "取款成功！余额为：" + act.getBalance());
    }
}

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占用的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，而导致线程都停止的情形，被称为“死锁”！某一个同步块同时拥有“两个对象以上的锁”，就有可能发生死锁问题！

//死锁测试 ：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLockTest {
    public static void main(String[] args) {
        Thread thread = new Thread(new Makeup(0, "第一个女孩"));
        Thread thread1 = new Thread(new Makeup(1, "第二个女孩"));
        thread.start();
        thread1.start();
    }
}
class Lipstick {}
class Mirror {}
class Makeup extends Thread {
    // static关键字保证获得的对象仅有一个
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    int choice;
    String name;
    public Makeup(int choice, String name) {
        this.choice = choice;
        this.name = name;
    }
    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void makeup() throws InterruptedException{
        if (choice == 0) {
            synchronized (lipstick) {
                System.out.println(this.name + "获得了口红的锁");
                Thread.sleep(1000);
                synchronized (mirror) {
                    System.out.println(this.name + "获得了镜子的锁");
                }
            }
        } else {
            synchronized (mirror) {
                System.out.println(this.name + "获得了镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick) {
                    System.out.println(this.name + "获得了口红的锁");
                }
            }
        }
    }
}

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用
请求与保持条件：一个进程因为请求资源而堵塞时，对已获得资源的保持不放
不剥夺条件：进程已经获得的资源，在未使用完之前，不能强行剥夺
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

以上列出了产生死锁的四个必要条件，我们只需要想办法破其中的任意一个或者多个条件就可以避免死锁的产生！在以上代码例子中，我们可以选择释放其中一方的资源，便可避免死锁的产生！

if (choice == 0) {
	synchronized (lipstick) {
    	System.out.println(this.name + "获得了口红的锁");
    	Thread.sleep(1000);
    }
    synchronized (mirror) {
    	System.out.println(this.name + "获得了镜子的锁");
    }
} else {
    synchronized (mirror) {
        System.out.println(this.name + "获得了镜子的锁");
        Thread.sleep(2000);
    }
    synchronized (lipstick) {
       	System.out.println(this.name + "获得了口红的锁");
    }
}

Lock锁

从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当！

ReentrantLock类（可重入锁）实现了Lock，它拥有synchronized相同的的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

public class LockTest implements Runnable {
    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        new Thread(lockTest,"t1").start();
        new Thread(lockTest,"t2").start();
        new Thread(lockTest,"t3").start();
    }
    private int ticked = 10;
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try { // 确保线程安全
                Thread.sleep(1000);
                lock.lock();
                if (ticked > 0) {
                    System.out.println(Thread.currentThread().getName() + "-->" + ticked--);
                } else {
                    return;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
                // 如果同步代码异常，要将unloc()放入finally语句块
            }
        }
    }
}

Lock与synchronized对比，Lock是显式锁（手动开启和手动关闭），synchronized是隐式锁，出了作用域自动释放。

Lock锁只有代码块锁，synchronized有代码块锁和方法锁。

使用Lock锁，JVM将花费较少时间来调度线程，性能更好，并且具有更好的扩展性（提供更多子类）。

优先使用顺序：Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）

线程协作

线程通信

应用场景：生产者与消费者问题

假设仓库中只能存放一件物品，生产者将生产出来的产品放入仓库，而消费者将产品从仓库里拿出。
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到消费者将产品从仓库拿出为止！
如果仓库中放有产品，则消费者可以将产品从仓库拿出！否则停止消费并等待！直到仓库中再次放入产品为止！

分析:

这是一个线程同步问题，生产者和消费者共享同一个资源，并且两者之间相互依赖，相互为条件！

对于生产者，没有生产产品之前，需要通知消费者进行等待，直到产品生产完毕，就立即通知消费者。
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产者生产新的产品以供消费！
在生产者消费者问题中，仅有synchronized是不够的！
- synchronized可阻止并发更新同一个资源，实现了同步。
- synchronized不能用来实现不同线程之间的消息传递(通信)。

Java提供了几个方法来解决线程之间的通信问题：

wait()	表示线程一直等待，直到其他线程通知，与sleep不同，该方法会释放锁！
wait(long timeout)	指定等待的毫秒数！
notify()	唤醒一个处于等待状态的线程！
notifyAll()	唤醒同一个对象上所有调用wait方法的线程，优先级别高的线程优先调度！

注意：以上方法均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常lllegalMonitorStateException！

方案一：管乘法

借助缓冲区实现！生产者将生产好的数据放入缓冲区，消费者从缓冲区拿取数据！

public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Productor(synContainer).start();
        new Consumer(synContainer).start();
    }
}
// 生产者
class Productor extends Thread {
    SynContainer container;
    public Productor(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        //生产
        for (int i = 0; i < 100; i++) {
            container.push(new Goods(i));
            System.out.println("生产者生产了" + i + "批货物！");
        }
    }
}
// 消费者
class Consumer extends Thread {
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }
    @Override
    public void run() {
        // 消费
        for (int i = 0; i < 100; i++) {
            System.out.println("消费者运走了" + container.pop().id + "批货物！");
        }
    }
}
// 产品
class Goods {
    int id; // 产品ID
    public Goods(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer {
    Goods[] goods = new Goods[10];
    int count = 0;
    // 生产者生产产品
    public synchronized void push(Goods good) {
        // 如果容器满了，则等待待消费者消费
        if (count == goods.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就丢入产品
        goods[count] = good;
        count++;
        this.notifyAll();
    }

    // 消费者消费产品
    public synchronized Goods pop() {
        if (count == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Goods oldGood = goods[count]; // 暂存被消费的产品
        this.notifyAll();
        return oldGood;
    }
}

方案二：信号灯法

使用标识位实现！通过标识位的变换，来改变线程的状态！

public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Actor(tv).start();
        new Audience(tv).start();
    }
}
class Actor extends Thread {
    TV tv;
    public Actor(TV tv) {
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i % 2 == 0) {
                this.tv.show("泰坦尼克号");
            } else {
                this.tv.show("爱丽丝梦游仙境");
            }
        }
    }
}
class Audience extends Thread {
    TV tv;
    public Audience(TV tv) {
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
                tv.watch();
        }
    }
}
class TV {
    String TVName;
    boolean flag = true;
    public synchronized void show(String TVName) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了" + TVName);
        this.notifyAll();
        this.TVName = TVName;
        this.flag = !this.flag;
    }
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了" + TVName);
        this.notifyAll();
        this.flag = !this.flag;
    }
}

线程池

当程序经常创建和销毁、使用量非常大的资源，比如并发情况下的线程，对性能影响非常大！这个时候，我们可以提前创建好线程，将线程扔入线程池中，使用时可以直接获取，使用完之后放回线程池中，可以避免频繁创建、销毁，实现重复利用。类似于现实生活中的公共交通工具！

线程池的优点：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中的资源，不需要每次创建）
便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止

在JDK5.0起提供了线程池子相关的API：ExecutorService和Executors

ExecutorService：真正的线程池接口，常见子类有ThreadPoolExecutor

void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
Futuresubmit(Callable task)：执行任务，有返回值，一般用来执行Callable
void shutdown()：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

public class TestPool {
    public static void main(String[] args) {
        // 创建服务，创建线程池
        // newFixedThreadPool(线程池大小)
        ExecutorService service = Executors.newFixedThreadPool(10);

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        // 关闭链接
        service.shutdown();
    }
}
class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程正在运行！");
    }
}