关于java:多线程详解

多任务→多线程

过程 VS 线程

程序是指令和数据的有序汇合，是一个动态的概念。
过程是程序的一次执行过程, 是一个动静的概念。
过程中至多有一个线程，线程是 CPU 调度和执行的根本单位。

三种创立形式：

继承 Thread 类
实现 Runnable 接口
实现 Callable 接口（理解）

创立线程形式一：继承 Thread 类→重写 run()办法→调用 start()启动线程

// 留神，线程开启不肯定立刻执行，由 CPU 调度执行
public class TestThread1 extends Thread{
    @Override
    public void run() {
        // run 办法线程体
        for(int i = 0;i < 20;i++) {System.out.println("我在看代码—————"+i);
        }
    }
    public static void main(String[] args) {
        //main 线程，主线程
        TestThread1 testThread1 = new TestThread1();
        // 调用 start()办法开启线程，交替执行
        testThread1.start();
        for(int i = 0;i < 20;i++) {System.out.println("我在学习多线程—————"+i);
        }
    }    
}

实现多线程同步下载图片

import java.io.File;
import java.net.URL;
import org.apache.commons.io.FileUtils;
public class TestThread2 extends Thread{
    private String url,name; // 网络图片地址，保留的文件名
    public TestThread2(String url,String name) {
        this.url = url;
        this.name = name;
    }
    // 下载图片线程执行体
    @Override
    public void run() {WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为："+name);
    }

    public static void main(String[] args) {TestThread2 t1 = new TestThread2("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","1.jpg");
        TestThread2 t2 = new TestThread2("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","2.jpg");
        TestThread2 t3 = new TestThread2("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","3.jpg"
        t1.start();
        t2.start();
        t3.start();}
}
 // 下载器
class WebDownloader{
    // 下载办法
    public void downloader(String url,String name) {
        try {FileUtils.copyURLToFile(new URL(url), new File(name));
        }catch (Exception e) {e.printStackTrace();
            System.out.println("IO 异样，downloader 办法呈现问题");
        }
    }
}

创立线程形式二：实现 Runnable 接口→重写 run()办法→调用 start()启动线程（须要 Runnable 接口实现类）

public class TestThread3 implements Runnable{
    @Override
    public void run() {
        // run 办法线程体
        for(int i = 0;i < 20;i++) {System.out.println("我在看代码—————"+i);
        }
    }
    public static void main(String[] args) {
        // 创立 runnable 接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        
        // 创立线程对象，通过线程对象来开启线程，代理
//        Thread thread = new Thread(testThread3);
//        thread.start();
        new Thread(testThread3).start();
        
        for(int i = 0;i < 20;i++) {System.out.println("我在学习多线程—————"+i);
        }
    }
}

import java.io.File;
import java.net.URL;
import org.apache.commons.io.FileUtils;
// 练习 Thread，实现多线程同步下载图片
public class TestThread2n implements Runnable{
    private String url,name; // 网络图片地址，保留的文件名
    public TestThread2n(String url,String name) {
        this.url = url;
        this.name = name;
    }
    // 下载图片线程执行体
    @Override
    public void run() {WebDownloader1 webDownloader = new WebDownloader1();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为："+name);
    }

    public static void main(String[] args) {TestThread2n t1 = new TestThread2n("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","1.jpg");
        TestThread2n t2 = new TestThread2n("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","2.jpg");
        TestThread2n t3 = new TestThread2n("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","3.jpg");
        
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();}

}
// 下载器
class WebDownloader1{
    // 下载办法
    public void downloader(String url,String name) {
        try {FileUtils.copyURLToFile(new URL(url), new File(name));
        }catch (Exception e) {e.printStackTrace();
            System.out.println("IO 异样，downloader 办法呈现问题");
        }
    }
}

小结：

继承 Thread 类
- 子类继承 Thread 类具备多线程能力
- 启动线程：子类对象.start()
- 不倡议应用：防止 OOP 单继承局限性
实现 Runnable 接口
- 实现接口 Runnable 具备多线程能力
- 启动线程：传入指标对象 +Thread 对象.start()
- 举荐应用：防止单继承局限性，灵便不便，不便同一对象被多个线程应用

多个线程同时操作一个对象，买火车票的例子

// 问题：多个线程操作同一个资源，线程不平安，数据错乱
public class TestThread4 implements Runnable{
    // 票数
    private int ticketNum = 10;
    @Override
    public void run() {while(true) {if(ticketNum<=0) {break;}
            try {Thread.sleep(10);
            } catch (Exception e) {e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNum--+"张票");
        }    
    }
    public static void main(String[] args) {TestThread4 ticket = new TestThread4();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();}
}

案例：龟兔赛跑

// 模仿龟兔赛跑
public class Race implements Runnable{
    // 胜利者
    private static String winner; 
    public static void main(String[] args) {Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();}
    @Override
    public void run() {for(int i = 0; i <= 100;i++) {
            // 模仿兔子劳动
            if("兔子".equals(Thread.currentThread().getName())&& i%10==5) {
                try {Thread.sleep(56);
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }
            if("乌龟".equals(Thread.currentThread().getName())) {
                try {Thread.sleep(5);
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }
            // 判断较量是否完结
            boolean flag = gameOver(i);
            // 如果较量完结了，就进行程序
            if(flag) {break;}
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }    
    }
    // 判断是否实现较量
    private boolean gameOver(int steps) {
        // 判断是否有胜利者
        if(winner!=null) {return true;}else {if(steps==100) {winner = Thread.currentThread().getName();
                System.out.println("winner is"+winner);
                return true;
            }
        }
        return false;
    }
}

创立线程形式三（理解即可）：实现 Callable 接口（须要返回值类型）→重写 call()办法（须要抛出异样）→创立指标对象→创立敞开服务

import java.io.File;
import java.net.URL;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.apache.commons.io.FileUtils;

// 创立形式三：实现 Callable 接口
/*
 * Callable 的益处：* 1. 能够定义返回值
 * 2. 能够抛出异样
 */
public class TestCallable implements Callable<Boolean>{
    private String url,name; // 网络图片地址，保留的文件名
    public TestCallable(String url,String name) {
        this.url = url;
        this.name = name;
    }
    // 下载图片线程执行体
    @Override
    public Boolean call() {WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为："+name);
        return true;
    }

    public static void main(String[] args) throws Exception {TestCallable t1 = new TestCallable("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","1.jpg");
        TestCallable t2 = new TestCallable("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","2.jpg");
        TestCallable t3 = new TestCallable("https://pics6.baidu.com/feed/838ba61ea8d3fd1ffe50b135beb0651894ca5f6d.jpeg?token=34d0744ffdbbc1f2d6ddea302862b052","3.jpg");
        
        // 创立执行服务 
        ExecutorService ser = Executors.newFixedThreadPool(3);
        
        // 提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        
        // 获取后果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        // 敞开服务
        ser.shutdown();}
}
 // 下载器
class WebDownloader{
    // 下载办法
    public void downloader(String url,String name) {
        try {FileUtils.copyURLToFile(new URL(url), new File(name));
        }catch (Exception e) {e.printStackTrace();
            System.out.println("IO 异样，downloader 办法呈现问题");
        }
    }
}

语法：(parameters) -> expression 或 (parameters) ->{statements;}

作用：简化代码，防止匿名外部类定义过多

Function Interface（函数式接口）：只蕴含惟一一个形象办法

能够通过 lamda 表达式来创立函数式接口的对象

推导 lambda 表达式

public class TestLambda1 {

    //3. 动态外部类
    static class Like2 implements ILike{

        @Override
        public void lambda() {System.out.println("I like lambda2");
        }
        
    }
    
    public static void main(String[] args) {ILike like = new Like();
        like.lambda();
        like = new Like2();
        like.lambda();
        
        //4. 部分外部类
        class Like3 implements ILike{

            @Override
            public void lambda() {System.out.println("I like lambda3");
            }        
        }
        like = new Like3();
        like.lambda();
        
        //5. 匿名外部类，没有类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {System.out.println("I like lambda4");
            }
        };
        like.lambda();
        
        //6. 用 lambda 简化
        like = () -> {System.out.println("I like lambda5");
        };
        like.lambda();}
}
//1. 定义一个函数式接口
interface ILike{void lambda();
}
//2. 实现类
class Like implements ILike{
    @Override
    public void lambda() {System.out.println("I like lambda");
    }    
}

简化 lambda 表达式：1. 省略参数类型 2. 省略括号

示例（婚庆公司）

public class StaticProxy {public static void main(String[] args) {You you = new You(); 
        you.HappyMarry();
        //        new Thread(()->System.out.println("我爱你")).start();
//        new WeddingCompany(new You()).HappyMarry();
        // 代理
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.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("结婚之前，安排现场");        
    }    
}

动态代理模式总结：

实在对象和代理对象都要实现同一个接口
代理对象代理实在对象

益处：

代理对象能够做很多实在对象做不了的事件
实在对象专一做本人的事件

不举荐应用 JDK 提供的 stop()、destroy()办法【已废除】
举荐线程本人停下来（倡议应用一标记位进行终止变量）

// 测试 stop
//1. 倡议线程失常进行 --> 利用次数，不倡议死循环
//2. 倡议应用标记位
//3. 不要应用 stop 或者 destroy 等过期或者 JDK 不倡议应用的办法
public class TestStop implements Runnable{
    private boolean flag = true;
    public static void main(String[] args) {TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for(int i = 0; i < 1000; i++) {System.out.println("main"+i);
            if(i == 900) {// 调用 stop()办法切换标记位，让线程进行
                testStop.stop();
                System.out.println("线程进行");
            }
        }
    }
    @Override
    public void run() {
        int i = 0;
        while(flag) {System.out.println("run ... Thread"+i++);
        }    
    }
    public void stop() {this.flag = false;}
}

sleep(毫秒)→就绪

每个对象有个锁，sleep 不会开释锁

// 模仿网络延时：放大问题的产生性
public class TestSleep implements Runnable{
    // 票数
    private int ticketNum = 10;
    @Override
    public void run() {while(true) {if(ticketNum<=0) {break;}
            // 模仿延时
            try {Thread.sleep(100);
            } catch (Exception e) {e.printStackTrace();
            }            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNum--+"张票");
        }    
    }
    public static void main(String[] args) {TestSleep ticket = new TestSleep();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();}
}

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep2{public static void main(String[] args) {
        // 模仿倒计时
        try {tenDown();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
        // 打印以后零碎工夫
        Date startTime = new Date(System.currentTimeMillis());
        while(true) {
            try {System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                Thread.sleep(1000);
                startTime = new Date(System.currentTimeMillis()); // 更新以后工夫
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();}
        }        
    }
    public static void tenDown() throws InterruptedException {
        int num = 3;
        while(true) {Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0) {break;}
        }    
    }
}

Yield 让以后线程暂停但不阻塞，转为就绪状态

礼让不肯定胜利

// 测试礼让线程，礼让不肯定胜利
public class TestYield {public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();}
}
class MyYield implements Runnable{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield(); // 礼让
        System.out.println(Thread.currentThread().getName()+"线程进行执行");
    }    
}

Join 合并线程，待此线程执行实现后，再执行其余线程，其余线程阻塞（能够看作是插队）

// 测试 join 办法
public class TestJoin implements Runnable{public static void main(String[] args) throws InterruptedException {
        // 启动咱们的线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        for (int i = 0; i < 500; i++) {if(i==200) {thread.join();// 插队
            }
            System.out.println("main"+i);
        }
    }
    @Override
    public void run() {for (int i = 0; i < 1000; i++) {System.out.println("线程 vip 来了"+i);
        }    
    }
}

优先高的不肯定先执行，默认是 5

// 测试线程的优先级
public class TestPriority{public static void main(String[] args) {
        // 主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        // 先设置优先级，再启动
        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY); //MAX_PRIORITY=10
        t4.start();}

}
class MyPriority implements Runnable{
    @Override
    public void run() {    System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
        
    }    
}

线程分为 用户线程 和守护线程

虚拟机必须确保用户线程（如，后盾记录操作日志，监控内存，垃圾回收期待）执行结束，但不必期待守护线程执行结束

// 测试守护线程
// 上帝守护你
public class TestDaemon {public static void main(String[] args) {God god = new God();
        You you = new You();
        Thread thread = new Thread(god);
        thread.setDaemon(true); // 默认是 false 示意是用户线程，失常的线程都是用户线程
        thread.start(); // 守护线程启动
        new Thread(you).start(); // 用户线程启动}
}
// 上帝
class God implements Runnable{

    @Override
    public void run() {while(true) {System.out.println("上帝保佑着你");
        }
    }    
}
// 你
class You implements Runnable{
    @Override
    public void run() {for (int i = 0; i < 36500; i++) {System.out.println("开心活着");
        }
        System.out.println("====Good bye!====");
    }    
}

多个线程操作同一资源（并发）

线程同步是一种 期待机制 ，多个须要同时拜访同一对象的线程进图该对象的 期待池 造成队列，期待后面线程应用结束，下一线程再应用

造成条件：队列 + 锁（synchronized）

1. 不平安的买票

// 不平安的买票(线程不平安）public class UnsafeBuyTicket {public static void main(String[] args) {BuyTicket station = new BuyTicket();
        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼的你们").start();
        new Thread(station,"可恶的黄牛党").start();}
    

}

class BuyTicket implements Runnable{
    
    // 票
    private int ticketNum = 10;
    boolean flag = true; // 内部进行形式
    @Override
    public void run() {
        // 买票
        while(flag) {buy();
        }
    }
    private void buy() {if(ticketNum<=0) {
            flag = false;
            return;
        }
        try {Thread.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
        // 买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
    }
    
}

2. 不平安的取钱

// 不平安的取钱（两个人）public class UnsafeBank {public static void main(String[] args) {Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing GF = new Drawing(account,100,"女朋友");
        you.start();
        GF.start();}

}
// 账户
class Account{
    int money; // 余额
    String name; // 卡名
    public Account(int money, String name) {super();
        this.money = money;
        this.name = name;
    }
}
// 银行：模仿取款
class Drawing extends Thread{
    Account account;
    // 取了多少钱
    int drawingMoney;
    // 当初手里有多少钱
    int nowMoney;
    public Drawing(Account account,int drawingMoney,String name) {super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }
    // 取钱
    @Override
    public void run() {
        // 判断有没有钱
        if(account.money - drawingMoney < 0) {System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }
        // 放大问题的产生性
        try {Thread.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
        // 卡内余额 = 余额 - 取的钱
        account.money = account.money - drawingMoney;
        // 你手里的钱
        nowMoney = nowMoney + drawingMoney;
        System.out.println(account.name+"余额为："+account.money);
        //Thread.currentThread() == this.getName()
        System.out.println(this.getName()+"手里的钱："+nowMoney);
    }
}

3. 不平安的汇合

// 线程不平安的汇合
// 增加到同一地位被笼罩
public class UnsafeList {public static void main(String[] args) {List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {new Thread(()->{list.add(Thread.currentThread().getName());
            }).start();}
        System.out.println(list.size());
    }
}

同步办法：public synchronized void method(int args) {}

synchronized 办法管制对“对象”的拜访，每个对象对象对应一把锁，每个 synchronized 办法都必须取得调用该办法的锁能力执行，否则线程会阻塞，办法一旦执行，就独占该锁，直到该办法返回才开释锁，前面被阻塞的线程能力取得这个锁，继续执行

同步块：synchronized(Obj) {}

Obj 称为同步监视器

Obj 能够是任何对象，然而举荐应用共享资源作为同步监视器
同步办法中无需指定同步监视器，因为同步办法的同步监视器就是 this

public void run() {
        // 锁的对象就是变动的量，须要增删改的对象
        synchronized (account) {
            // 判断有没有钱
            if(account.money - drawingMoney < 0) {System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }
            // 放大问题的产生性
            try {Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();}
            // 卡内余额 = 余额 - 取的钱
            account.money = account.money - drawingMoney;
        }
        // 你手里的钱
        nowMoney = nowMoney + drawingMoney;
        System.out.println(account.name+"余额为："+account.money);
        //Thread.currentThread() == this.getName()
        System.out.println(this.getName()+"手里的钱："+nowMoney);
    }

JUC 就是 java.util .concurrent 工具包的简称。这是一个解决线程的工具包，JDK 1.5 开始呈现的。Callable 接口也在 JUC 中。

import java.util.concurrent.CopyOnWriteArrayList;

// 测试 JUC 平安类型的汇合
public class TestJUC {public static void main(String[] args) {CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for(int i = 0; i < 10000; i++) {new Thread(()->{list.add(Thread.currentThread().getName());
            }).start();}
        try {Thread.sleep(3000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
        System.out.println(list.size());
    }
}

多个线程各自占有一些共享资源，并且相互期待其余线程占有的资源能力运行，而导致两个或者多个线程都在期待对方开释资源，都进行执行的情景，某一同步块同时领有”两个以上对象的锁“时，就可能会产生”死锁“的问题

// 死锁：多个线程相互抱着对方须要的资源，而后造成僵持
public class DeadLock {public static void main(String[] args) {Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2 = new Makeup(1,"白雪公主");
        g1.start();
        g2.start();}

}
// 口红
class Lipstick{ }
// 镜子
class Mirror{ }
class Makeup extends Thread{
    // 须要的资源只有一份，用 static 来保障只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    
    int choice; // 抉择
    String girlName; // 抉择化妆品的人
    
    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }
    @Override
    public void run() {
        // 化妆
        try {makeup();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
    
    // 化妆，相互持有对方的锁，就是须要拿到对方的资源
    private void makeup() throws InterruptedException {if(choice == 0) {synchronized(lipstick) { // 取得口红的锁
                System.out.println(this.girlName+"取得口红的锁");
                Thread.sleep(1000);
            
                synchronized(mirror) {System.out.println(this.girlName+"取得镜子的锁");
                }
            }
        }else {synchronized(mirror) { // 取得口红的锁
                System.out.println(this.girlName+"取得镜子的锁");
                Thread.sleep(2000);
            
                synchronized(lipstick) {System.out.println(this.girlName+"取得口红的锁");
                }
            }
        }
    }
}

锁中锁（多个对象相互嵌套的锁）使多个线程相互抱着对方须要的资源，而后造成僵持

解决办法：锁离开写，不要同时占有多个资源

// 化妆，相互持有对方的锁，就是须要拿到对方的资源
    private void makeup() throws InterruptedException {if(choice == 0) {synchronized(lipstick) { // 取得口红的锁
                System.out.println(this.girlName+"取得口红的锁");
                Thread.sleep(1000);
            }
            synchronized(mirror) {System.out.println(this.girlName+"取得镜子的锁");
                }
        }else {synchronized(mirror) { // 取得口红的锁
                System.out.println(this.girlName+"取得镜子的锁");
                Thread.sleep(2000);
            }
            synchronized(lipstick) {System.out.println(this.girlName+"取得口红的锁");
                }
        }

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

互斥条件
申请与放弃条件
不剥夺条件
循环期待条件

从 JDK 5.0 开始，Java 提供了更弱小的线程同步机制——显式定义同步锁对象来实现同步。同步锁应用 Lock 对象充当，Lock 锁也蕴含在 JUC 内

ReentrantLock（可重入锁）类实现了 Lock，能够显式加锁、开释锁

应用格局：

Lock lock=new ReentrantLock();
lock.lock();
try{// 解决工作}catch(Exception ex){ }finally{lock.unlock();   // 开释锁
}

测试 Lock 类（买票）：

import java.util.concurrent.locks.ReentrantLock;

// 测试 Lock 类
public class TestLock {public static void main(String[] args) {TestLock2 testLock2 = new TestLock2(); 
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();}
}
class TestLock2 implements Runnable{
    int ticketNum = 10;
    
    // 定义 Lock 锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {while(true) {lock.lock();// 加锁
            try {if(ticketNum > 0) {
                    try {Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();}
                    System.out.println(ticketNum--);
                }else {break;}
            }finally {
                // 解锁
                lock.unlock();}        
        }
    }
}

synchronized 与 Lock 比照

Lock 是显式锁（手动开启和敞开锁），synchronized 是隐式锁，主动开释
应用 Lock 锁，JVM 将破费较少的工夫来调度线程，性能更好。并且具备更好的扩展性（提供更多子类）

线程通信办法：

留神：均是 Object 类的办法，都只能在同步办法或者同步代码块中应用，否则会抛出异样

解决办法：

利用缓冲区解决：管程法

// 测试生产者消费者模型 --> 利用缓冲区解决：管程法

// 生产者，消费者，产品，缓冲区
public class TestPC {public static void main(String[] args) {SynContainer container = new SynContainer();        
        new Producer(container).start();
        new Consumer(container).start();}

}

// 生产者
class Producer extends Thread{
    SynContainer container;
    public Producer(SynContainer container) {this.container = container;}
    
    // 生产
    @Override
    public void run() {for (int i = 0; i < 100; i++) {container.push(new Chicken(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 Chicken{
    int id; // 产品编号
    public Chicken(int id) {this.id = id;}    
}

// 缓冲区
class SynContainer{
    // 须要一个容器大小
    Chicken[] chickens = new Chicken[10];
    // 容器计数器
    int count = 0;
    
    // 生产者放入产品
    public synchronized void push(Chicken chicken) {
        // 如果容器满了，就须要期待消费者生产
        if(count == chickens.length) {
            // 告诉消费者生产，生产期待
            try {this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();}
        }
        // 如果没有满，咱们就须要丢入产品
        chickens[count] = chicken;
        count++;
        
        // 能够告诉消费者生产了
        this.notifyAll();}

    // 消费者生产产品
    public synchronized Chicken pop() {
        // 判断是否生产
        if(count==0) {
            // 期待生产者生产
            try {this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();}
        }
        // 如果能够生产
        count--;
        Chicken chicken = chickens[count];    
        // 吃完了，告诉生产者生产
        this.notifyAll();
        return chicken;
        
    }
}

利用标记位解决：信号灯法

package com.zhg.thread;

// 测试生产者消费者模型 2 --> 利用标记位解决：信号灯法
public class TestPC2 {public static void main(String[] args) {TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();}

}

// 生产者 --> 演员
class Player extends Thread{
    TV tv;
    public Player(TV tv) {this.tv = tv;}
    @Override
    public void run() {for (int i = 0; i < 20; i++) {if(i%2==0) {this.tv.play("高兴大本营");
            }else {this.tv.play("广告");
            }
        }
    }
}

// 消费者 --> 观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv) {this.tv = tv;}
    @Override
    public void run() {for (int i = 0; i < 20; i++) {tv.watch();
        }
    }
}

// 产品 --> 节目
class TV{
    
    // 演员表演，观众期待 T
    // 观众观看，演员期待 F
    String voice;// 表演的节目
    boolean flag = true;
    
    // 表演
    public synchronized void play(String voice) {if(!flag) {
            try {this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();}
        }
        
        System.out.println("演员表演了："+voice);
        // 告诉观众观看
        this.notifyAll(); // 告诉唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }
    
    // 观看
    public synchronized void watch() {if(flag) {
            try {this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();}
        }
        System.out.println("观众观看了："+voice);
        // 告诉演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

背景：常常创立和销毁，使用量特地大的资源，比方并发状况下的线程，对性能影响很大。

思路：提前创立好多个线程，放入线程池中，应用时间接获取，应用完放回池中。能够防止频繁创立销毁、实现反复利用。

益处：

进步响应速度
升高资源耗费
便于线程治理

JDK 5.0 起提供了线程池相干 API：ExecutorService 和 Executors

ExecutorService：真正的线程池接口。
Executor：工具类、线程池的工厂类，用于创立并返回不同类型的线程池。

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

// 测试线程池
public class TestPool {public static void main(String[] args) {
        //1. 创立服务，创立线程池
        //newFixedThreadPool 参数为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2. 敞开连贯
        service.shutdown();}
}

class MyThread implements Runnable{

    @Override
    public void run() {System.out.println(Thread.currentThread().getName());
        
    }
}

关于java:多线程详解

1.1 线程简介

1.2 线程创立

1.2.1 继承 Thread 类

1.2.2 实现 Runnable 接口

1.2.3 实现 Callable 接口

Lamda 表达式

动态代理

1.3 线程状态

1.3.1 五大状态

1.3.2 线程进行

1.3.3 线程休眠

1.3.4 线程礼让

1.3.5 线程强制执行

1.3.6 线程优先级

1.3.7 守护（daemon）线程

1.4 线程同步

1.4.1 同步办法及同步块

三个不平安案例

synchronized

CopyOnWriteArrayList

1.4.2 死锁

1.4.3 Lock 锁

1.4.4 线程通信

生产者消费者问题

线程池