Java之多线程学习

Posted 2021-12-05 乐呵。

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java之多线程学习相关的知识，希望对你有一定的参考价值。

Process(进程)与Thread(线程)

程序是指令和数据的有序集合，其本身没有任何运行含义，是一个静态的概念。

而进程则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位

通常在一个进程中可以包含若干个线程（gc线程），当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

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

线程核心概念

线程就是独立的执行路径；

在程序运行时，即使自己没有创建线程，后台也会有多个线程，如主线程，gc线程；

main()称之为主线程，为系统的入口，用于执行整个程序；

在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。

对同一份资源操作时，会存在资源抢夺的情况，需要加入并发控制；

线程会带来额外的开销，如cpu调度时间，并发控制开销。

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程创建

三种创建方式：

Thread class 继承Thread类（重点）

Runnable 接口实现Runnable接口（重点）

Callable 接口实现Callable接口（了解）

Thread

自定义线程类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

public class StartThread1 extends Thread{
   //线程不一定立即执行，由CPU安排调度
   //线程入口点
   @Override
   public void run() {
      //线程体
   }
   
   public static void main(String[] args) {
      //创建线程对象
      StartThread1 t = new StartThread1();
      t.start();			//调用start()方法启动线程
   }
}

Runnable

定义MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

public class StartThread2 implements Runnable {
   
   @Override
   public void run() {
      //线程体
   }
   
   public static void main(String[] args) {
      //创建实现类对象
      StartThread2 st = new StartThread2();
      //创建代理类对象
      Thread thread = new Thread(st);
      //启动
      thread.start();
   }
}

//推使用Runnable对象，因为Java单继承的局限性

小结

继承Thread类

子类继承Thread类具备多线程能力

启动线程：子类对象 . start()

不建议使用：避免OOP单继承局限性
实现Runnable接口

实现接口Runnable具有多线程能力

启动多线程：传入目标对象+Thread对象 . start()

推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
//一份资源
StartThread3 station = new StartThread3();

//多个代理
new Thread(station,"小明").start();
new Thread(station,"小红").start();
new Thread(station,"大哥").start();

Callable接口（了解即可）

实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行：Future result1 = ser.submit(t1);
获取结果：boolean r1 = result1.get()
关闭服务：ser.shutdownNow();

public class TestCallable implements Callable<Boolean> {			//<添加返回值类型>
   @Override
   public Boolean call() {						//拥有返回值
      System.out.println("调用成功，继续学习！！");
      return true; 
   }
   
   public static void main(String[] args) throws ExecutionException,InterruptedException {
      //创建了3个线程
      TestCallable t1 = new TestCallable();
      TestCallable t2 = new TestCallable();
      TestCallable t3 = new TestCallable();
      
      //创建执行服务：
      ExecutorService ser = Executors.newFixedThreadPool(3); //创建了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();		
      //关闭服务
      ser.shutdownNow();
   }
}

静态代理模式

//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实对象

//好处：
	//代理对象可以做很多真实对象做不了的事情
	//真实对象专注做自己的事情

public class Demo4 {
    public static void main(String[] args) {
        You you=new You();
        Wedding wedding=new Wedding(you);
        wedding.HaapyMarry();
    }
}

interface Marry{
    void HaapyMarry();
}

//真实对象
class You implements  Marry{
    @Override
    public void HaapyMarry() {
        System.out.println("效果变化！！！！！！！！");
    }
}

//代理角色代理真实对象
class Wedding implements Marry{
    private Marry target;           //接收真实对象
   public Wedding(Marry target){
       this.target=target;
   }
    public void HaapyMarry(){			//实现接口方法
        befor();
        this.target.HaapyMarry();			//调用target的HaapyMarry()方法
        after();
    }
    private void befor(){
        System.out.println("效果布置现场！！！！！！");
    }
    private void after(){
        System.out.println("效果之后布置现场！！！！");
    }
}

Lamda表达式

理解Functional Interface（函数式接口）是学习Java8 Lamda表达式的关键所在。

避免匿名内部类定义过多。

函数式接口的定义：

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

对于函数式接口，我们可以通过Lamda表达式来创建该接口的对象。

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

演示：代码推导Lamda表达式

public class Demo {

    //3、静态内部类
    static class Like2 implements ILike{
        public void lambda(){
            System.out.println("I like lambda----2");
        }
    }

    public static void main(String[] args) {
            ILike like=new Like1();		//创建ILike接口实现类
            like.lambda();

            like=new Like2();
            like.lambda();

            //4、局部内部类
            class Like3 implements ILike{
                public void lambda(){
                    System.out.println("I like lambda----3");
                }
            }

            like=new Like3();
            like.lambda();


            //5、匿名内部类，没有类的名称，必须借助接口或者父类
            like=new ILike() {
                @Override
                public void lambda() {
                    System.out.println("I like lambda----4");
                }
            };
            like.lambda();


            //6、lambda简化
            like=()->{  System.out.println("I like lambda----4");};
            like.lambda();
       
    }		//main()结束
}		//Demo类结束

//1、定义一个函数式接口
interface ILike{
    void lambda();
}

//2、实现接口
class Like1 implements ILike{
    public void lambda(){
        System.out.println("I like lambda----1");
    }
}

public class Demo {
   //注意观察去掉的部分
    public static void main(String[] args) {
        Like like=(int a)->{
            System.out.println("you is preson"+a);
        };
        like.limb(1);

        //简化1，去掉参数类型
        like=(a)->{
            System.out.println("you is preson"+a);
        };
        like.limb(2);

        //简化2，去掉括号
        like=a->{
            System.out.println("you is preson"+a);
        };
        like.limb(3);

        //简化3，去掉花括号
        like=a->System.out.println("you is preson"+a);
        like.limb(4);

        /**
         * 总结：
         * lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，就必须用代码块包裹{}
         * 前提是接口为函数式接口
         * 多个参数也可以去掉参数类型，要去就全部去掉类型，必须加上括号()
         */
    }
}

interface Like{
    void limb(int a);
}

线程状态

停止线程

不推荐使用JDK提高的stop()、destroy()方法。

推荐线程线程自己停下来

建议使用一个标志位进行终止变量，当flag=false，则终止线程运行。
public class TestStop implements Runnable {
   //1.线程中定义线程体使用的标识
   private boolean flag = true;
   
   @Override
   public void run() {
      //2.线程体使用该标识
      while (flag) {
         System.out.println("run...Thread");
      }
   }
   
   //3.对外提供方法改变标识
   public void stop() {
      this.flag = false;
   }
}

线程休眠

sleep（时间）指定当前线程阻塞的毫秒数；
sleep存在异常InterruptedException；
sleep时间达到后线程进入就绪状态；
sleep可以模拟网络延时，倒计时等。
每一个对象都有一个锁，sleep不会释放锁；

public class Demo8 implements Runnable{
   
private static boolean flas=true;       //标志循环停止变量

   public void run(){
        try {
            at_Present_Date();
        } catch (InterruptedException e) {
            e.printStackTrace(); }
    }
   
private static void at_Present_Date() throws InterruptedException {
        Date starTime=new Date(System.currentTimeMillis());//获取系统当前时间
        while (flas){
            Thread.sleep(1000);//休眠一秒
            System.out.println(new SimpleDateFormat("HH点:mm分:ss秒").format(starTime));//打印时间
            starTime=new Date(System.currentTimeMillis());//更新当前时间
        }
}

public static void main(String[] args) throws InterruptedException {
            new Thread(new Demo8()).start();//启动多线程
            Thread.sleep(10000);//休眠10秒后关闭线程
            Demo8.flas=false;//转换变量
    }
}

线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度，礼让不一定成功！

public class Demo9 implements Runnable{
    //线程的礼让
    public void run(){
        System.out.println("线程 "+Thread.currentThread().getName()+"开始运行！！！");
        Thread.yield();
        System.out.println("线程 "+Thread.currentThread().getName()+"结束运行！！！");
    }

    public static void main(String[] args) throws InterruptedException {
        Demo9 demo9=new Demo9();
        new Thread(demo9,"a").start();
        new Thread(demo9,"b").start();
        
        new InSert().fun();

    }
}

class InSert implements Runnable{
    public void run(){
        System.out.println("我从中间插入进来！！！！！！！！！！！");
    }
    public static void fun(){
        InSert sert=new InSert();
        new Thread(sert).start();
       try {
           for (int i=1;i<=20;i++){
               if(i==10){
                   new Thread(sert).join();
               }
               System.out.println("当前打印数字为："+i);
           }
       }catch (Exception e){
           e.printStackTrace();
       }
    }
}

线程强制执行——join

Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞，可以想象成插队

public class Person implements Runnable{
    public void run() {
        System.out.println("老子VIP,闪一边去！！！");
    }

    public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread(new Person());
        thread.start();
       for (int i=0;i<3;i++) {
           if (i==1) {
               thread.join();
           }
           System.out.println("慢慢排队中！！！");
       }
    }
}

线程观测状态

Thread.State

线程可以处于以下状态之一：

NEW 尚未启动的线程处于此状态。

RUNNABLE 在Java虚拟机中执行的线程处于此状态。

BLOCKED 被阻塞等待监视器锁定的线程处于此状态。

WAITING 正在等待另一个线程执行特定动作的线程处于此状态。

TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

TERMINATED 已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态
public class Demo10 {

    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{  //Lamda表达式写法
            for (int i=0;i<5;i++){
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }//try...catch结束
            }//for循环结束
            System.out.println("#########");
        });

        //观察状态
        Thread.State state=thread.getState();
        System.out.println(state);//NEW

        //启动后状态
        thread.start();
        state=thread.getState();    //获取线程状态
        System.out.println(state);//Run

        while (state!=Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state=thread.getState();    //更新线程状态
            System.out.println(state);  //输出线程状态
        }
    }
}

线程优先级

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

该调度哪个线程来执行。

线程的优先级用数字表示，范围从1--10。

Thread.MIN_PRIORITY = 1;

Thread.MAX_PRIORITY = 10;

Thread.NORM_PRIORITY = 5;

使用以下方式改变或获取优先级

getPriority(). setPriority( int xxx )

优先级设定建议在start()调度前

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度
//线程的优先级设置和获取测试。

public class Demo11 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
        //主线程的优先级打印
        TestSetPriority t=new TestSetPriority();
        Thread t1=new Thread(t,"长江");
        Thread t2=new Thread(t,"黄河");
        Thread t3=new Thread(t,"湖泊");
        Thread t4=new Thread(t,"大海");
        t1.setPriority(6);//设置优先级
        t1.start();
        t2.setPriority(2);
        t2.start();
        t3.setPriority(Thread.MAX_PRIORITY);//最高级
        t3.start();
        t4.setPriority(7);
        t4.start();
    }
}

class TestSetPriority implements Runnable{
    public void run(){
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());
        //获取优先级
    }
}

守护线程

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

public class Demo {
    public static void main(String[] args) {
            God god=new God();
            Your your=new Your();
            Thread thread=new Thread(god);
            thread.setDaemon(true);     //一般为false为用户线程，设置为true为守护线程
            thread.start();             //启动守护线程
            new Thread(your).start();   //启动用户线程
    }
}

//声明一个守护线程
class God implements Runnable{
    public void run(){
        while (true){
            System.out.println("爸爸一直在守护着你");
        }//while循环结束
    }
}//God类结束

//声明一个用户线程
class Your implements Runnable{
    @Override
    public void run() {
            for (int i=0;i<100;i++){
                System.out.println("老子要飙车！！！！！！！！");
            }
    }
}//Your类结束

线程的同步

多个线程操作同一个资源

“ 同一个资源，多个人都想使用 “ 的问题，比如食堂排队打饭，都想吃饭，解决办法：排队

并发：同一个对象被多个线程同时操作

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时便需要线程同

步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队

列，等待前面线程使用完毕，下一个线程再使用

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保

证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized,当一个线程获得对象的排它

锁，独占资源，其他线程必须等待，使用后释放锁即可。

存在以下问题：

一个线程持有锁会导致其他所有需要此锁的线程挂起；

在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；

如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级导致，引发性能问题.

//线程不安全用例
public class Demo13 {

    public static void main(String[] args) {
        Account account=new Account(100,"买房基金");	//同一资源
        Drawing man=new Drawing(account,50,"man");	//男人对象
        Drawing woman=new Drawing(account,100,"woman");	//女人对象

        man.start();
        woman.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 drawingMoney;   //取了多少钱
        int nowMoney;       //现在手里有多少钱

        public Drawing(Account account,int drawingMoney,String name){
            super(name);
            this.account=account;
            this.drawingMoney=drawingMoney;
        }

        //取钱
        public void run(){
            //判断有没有钱
            //锁的对象就是变化的量，需要增删改查的对象
            synchronized (account) {
                if(account.money-drawingMoney<0){
                    System.out.println(Thread.currentThread().getName()+"钱不够，取不了！！！");
                    return;
                }

                //sleep可以放大问题的发生性
                try {
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }

                //卡内余额：余额 - 取的钱
                account.money=account.money-drawingMoney;
                //你手中的钱
                nowMoney=nowMoney+drawingMoney;

                System.out.println(account.name+":余额为"+account.money);
                // Thread.currentThread().getName()==this.getName()
                System.out.println(this.getName()+"手里的钱： "+nowMoney);
            }
        }

}

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块

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

同步方法：
public synchronized void method (int args) {}
缺陷：若将一个大的方法声明为synchronized将会影响效率

同步块

Obj称之为同步监视器

Obj可以是任何对象，但是推荐使用共享资源作为同步监视器

同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

同步监视器的执行过程

第一个线程访问，锁定同步监视器，执行其中代码.

第二个线程访问，发现同步监视器被锁定，无法访问.

第一个线程访问完毕，解锁同步监视器.

第二个线程访问，发现同步监视器没有锁，然后锁定并访问.

同步块：
synchronized (Obj) {}

public class Demo {

    public static void main(String[] args) {
			//账户
        Account account=new Account(100,"买房基金");
        //取钱对象
        Drawing man=new Drawing(account,50,"man");
        Drawing woman=new Drawing(account,100,"woman");
			
        man.start();
        woman.start();
    }		//main方法结束
}	//Demo类结束
//账户
class Account{
        int money;	//余额
        String name;		//卡名
        public Account(int money,String name){
            this.money=money;
            this.name=name;
        }	//Account构造方法结束
}		//Account类结束

//银行：模拟取钱
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;
        }		//Drawing构造方法结束

        //取钱
   	  //synchronized 默认锁的是this
        public void run(){
           //锁的对象就是变化的量，需要增删改查的对象
           synchronuzed (account){
               //判断有没有钱
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了！！！");
                return;		//终止程序
            }	//if判断结束

            //sleep可以放大问题的发生性
           try {
               Thread.sleep(1000);
           }catch (Exception e){
               e.printStackTrace();
           }	//try...catch方法结束

            //卡内余额：余额 - 取的钱
            account.money=account.money-drawingMoney;
            //你手中的钱
            nowMoney=nowMoney+drawingMoney;

            System.out.println(account.name+":余额为"+account.money);
            // Thread.currentThread().getName() = this.getName()
            System.out.println(this.getName()+"手里的钱： "+nowMoney);
        } 	//同步块结束
    }		//run()方法结束
}		//Drawing类结束

死锁

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

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

互斥条件：一个资源每次只能被一个进程使用。

请求与保持条件：一个进程因请求资源而堵塞时，对已获得资源保持不放。

不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。

循环等待条件：若干进程之间形成一种头尾相接的循环的等待资源关系。

上面列出死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

public class DeadLock {
    public static void main(String[] args) {
            Makeup g1 = new Makeup(0,"灰姑娘");
            Makeup g2 = new Makeup(0,"白雪公主");
            g1.start();	//启动线程
            g2.start();
    }
}
//口红
class Lipstick {
}
//镜子
class Mirror {
}

class Makeup extends Thread {
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;     //选择
    String girName;     //使用化妆品的人

    public Makeup(int choice, String girName) {
        this.choice = choice;
        this.girName = girName;
    }

    @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.girName + "获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror) {     //一秒后想获得镜子的锁
                    System.out.println(this.girName + "获得镜子的锁");
                }   //synchronized同步块结束
            }   //synchronized同步块结束
        } else {
            synchronized (mirror) {   //获得镜子的锁
                System.out.println(this.girName + "获得口红的锁");
                Thread.sleep(2000);
                synchronized (lipstick) {   //一秒后想获得口红的锁
                    System.out.println(this.girName + "获得口红的锁");
                }   //synchronized同步块结束
            }   //synchronized同步块结束
        }   //if...else 结束
*/
        //解决方法
        if (choice == 0) {
            synchronized (lipstick) {   //获得口红的锁
                System.out.println(this.girName + "获得口红的锁");
                Thread.sleep(1000);
            }   //synchronized同步块结束
            synchronized (mirror) {     //一秒后想获得镜子的锁
                System.out.println(this.girName + "获得镜子的锁");
            }   //synchronized同步块结束
        } else {
            synchronized (mirror) {   //获得镜子的锁
                System.out.println(this.girName + "获得口红的锁");
                Thread.sleep(2000);
            }   //synchronized同步块结束
            synchronized (lipstick) {   //一秒后想获得口红的锁
                System.out.println(this.girName + "获得口红的锁");
            }   //synchronized同步块结束
        }   //if...else 结束

    }   //makeup()方法结束
}   //Makeup类结束

Lock（锁）

Java通过了更强大的线程同步机制----通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资

源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的

控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁。
class A {
   private final ReentrantLock lock = new ReentrantLock();
   public void run() {
      lock.lock();
      try{
         //保证线程安全的代码
      }finally {
         lock.unlock();
         //如果同步代码有异常，要将unlock()写入finally语句块，释放锁
      }//try...cath结束
   }//run()方法结束
}//A类结束

synchronized 与 Lock 的对比

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

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

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

类）

优先选择顺序：

Lock > 同步代码块(已经进入了方法体，分配了相应资源) > 同步方法(在方法体外)

线程通信

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

注意:均是Object类的方法，都只能在同步方法或同步代码块中使用，否则会抛出异常IllegaIMonitorStateException

notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。

生产者与消费者问题

并发协作模型 ”生产者 / 消费者“

生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；

消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；

缓冲区：消费者不能直接使用生产者的数据，他们之间有个 “缓冲区”

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

管存法

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

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

//生产者
class Productor extends Thread {
     SynContainer container;
     public Productor (SynContainer container) {
             this.container = container;
     }
     //生产
     public void run () {
         for (int i=0;i<100;i++) {
             container.push(new Chicken(i));
             System.out.println("生产了 "+i+" 只鸡");
         }
     }
}

//消费者
class Cosumer extends Thread {
 SynContainer container;
 public Cosumer (SynContainer container) {
     this.container = container;
 }
     //消费
 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) {
             e.printStackTrace();
         }
     }

     chickens[count] = chicken;
     count++;

     //可以通知消费者消费了。
     this.notifyAll();
 }

 //消费者消费产品
 public synchronized Chicken pop () {
     //判断能否消费
     if (count==0) {
         //等待生产者生产，消费者等待
         try {
             this.wait();
         }catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

     //如果可以消费
     count--;
     Chicken chicken = chickens[count];

     //吃完了，通知生产者生产
     this.notifyAll();
     return chicken;
 }
}

信号灯法

//测试生产者消费者问题2：信号灯法标志位解决

public class Demo {	//主类
 public static void main(String[] args) {
     TV tv = new TV();
     new Player(tv).start();
     new Watchar(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++) {
         try {
             if (i%2==0){
                 this.tv.play("快乐大本营播放中");
             }else {
                 this.tv.play("抖音：记录美好生活");
             }
         }catch (Exception e) {
             e.printStackTrace();
         }
     }//for循环结束
 }//run方法结束
}

//消费者———>观众
class Watchar extends Thread {
 TV tv;
 public Watchar(TV tv) {
     this.tv = tv;
 }
 @Override
 public void run() { //观看节目
     for (int i=0;i<20;i++) {
         try {
             tv.watch();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }//for循环结束
 }//run方法结束
}

//产品———节目
class TV {
 //演员表演，观众等待 T
 //观众观看，演员等待 F
 String voice;   //表演的节目
 boolean flag = true;

 //表演
 public synchronized void play(String voice) throws InterruptedException {
     if (!flag) {
         this.wait();
     }
     System.out.println("演员表演了： "+voice);
     //通知观众观看
     this.notifyAll();   //通知唤醒
     this.voice = voice;
     this.flag = !this.flag;
 }

 //观看
 public synchronized void watch() throws InterruptedException {
     if (flag) {
         this.wait();
     }
     System.out.println("观看了： "+voice);
     this.notifyAll();
     this.flag = !this.flag;
 }
}

线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中，避免频繁的销毁与创

建，实现重复利用。

好处：

提高响应速度（减少了创建新线程的时间）

降低资源损耗（重复利用线程池中线程，不需要每次都创建）

便于管理

corePoolSize：核心池的大小

maximumPoolSize：最大线程数

keepAliveTime：线程没有任务时最多保持多长时间后会终止

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

ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor

void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable

Futuresubmit(Callabletask)：执行任务，有返回值，一般用来执行Callable

void shutdown()：关闭线程池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool  参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(5);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdown();
    }
}

class MyThread implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

以上是关于Java之多线程学习的主要内容，如果未能解决你的问题，请参考以下文章