LAGOU18 多线程

最新推荐文章于 2021-02-13 00:13:25 发布

憨憨老婆伍

最新推荐文章于 2021-02-13 00:13:25 发布

阅读量178

点赞数

分类专栏： LAGOU课程文章标签： java

本文链接：https://blog.csdn.net/hwinte/article/details/106317409

版权

LAGOU课程专栏收录该内容

19 篇文章 0 订阅

订阅专栏

18.1.1 程序和进程的概念
程序：数据结构+算法，主要是指存放在硬盘上的可执行文件；
进程：主要是指运行在内存中的可执行文件；
可执行文件放着叫程序，在内存中运行起来了就叫进程；
目前主流的操作系统都支持多进程，为了让操作系统同时可以执行多个任务，但进程是重量级的，也就是新建一个进程会消耗CPU和内存空间等系统资源，因此进程的数量比较局限；
18.1.2 线程的概念
为了解决上述问题就提出线程的概念，线程就是进程内部的程序流，也就是说操作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是轻量的，新建线程会共享所在进程的系统资源，因此目前主流的开发都是采用多线程；
多线程是采用时间片轮转法来保证多个线程的并发执行，所谓并发就是指宏观并行微观串行的机制；=>每个线程分配一个很小的时间片，迅速切换！
18.2 线程的创建
18.2.1 Thread类的概念
java.lang.Thread类代表线程，任何线程对象都是Thread类（子类）的实例；
Thread类是线程的模板，封装了复杂的线程开启等操作，封装了操作系统的差异性；
18.2.2 创建方式
自定义类继承Thread类并重写run方法，然后创建该类的对象调用start方法；
自定义类实现Runnable接口并重写run方法，创建该类的对象作为实参来构造Thread类型的对象，然后使用Thread类型的对象调用start方法；
18.2.3 相关的方法

方法声明	功能介绍
Thread()	使用无参的方式构造对象
Thread(String name)	根据参数指定的名称来构造对象
Thread(Runnable target)	根据参数指定的引用来构造对象，其中Runnable是个接口类型
Thread(Runnable target,String name)	根据参数指定引用和名称来构造对象
void run()	若使用Runnable引用构造了线程对象，调用该方法时最终调用接口中的版本< br/>；若没有使用Runnable引用构造线程对象，调用该方法时则啥也不做(前两个版本)；
void start()	用于启动线程，java虚拟机会自动调用该线程的run方法

我们用代码测试一下表格中的void run()方法：

package com.lagou.task08;

public class ThreadTest{

    public static void main(String[] args) {
        //1.使用无参方式构造Thread类型的对象
        //有源码可知：Thread类中的成员变量Target的数值为null
        Thread t1=new Thread();
        //2.调用run方法进行测试
        //由源码可知：由于成员变量target的数值为null，因此条件if(target!=null)不成立，跳过{}中的代码不执行
        //而run()方法中除了上述代码再无代码，因此证明run方法确实啥也不干
        t1.run();
        //3.打印一句话
        System.out.println("我想看看你到底是否真的啥也不干");
    }
}

输出结果为：
我想看看你到底是否真的啥也不干
可知，使用无参方式构造Thread类型的对象，类中的target变量数值为null，因此run方法未运行，确实啥也没干；
由此我们就理解了自定义类继承Thread类并重写run方法这句话了，
我们再写一个类重写run方法：

package com.lagou.task08;

public class SubThreadRun extends Thread{

    @Override
    public void run() {
        //打印1-20之间的所有整数
        for(int i=1;i<20;i++)
        {
            System.out.println("run方法中：i="+i);
        }
    }
}

然后再写一个类来调用这个方法：

package com.lagou.task08;

public class SubThreadRunTest {
    public static void main(String[] args) {
        //1.声明Thread类型的引用指向子类类型的对象
        Thread t1=new SubThreadRun();
        //2.调用run方法测试：本质上就是相当于对普通成员方法的调用，因此执行流程就是run方法的代码执行完毕后才能继续向下执行
        t1.run();
 
        //打印1-20之间的所有整数
        for(int i=1;i<20;i++)
        {
            System.out.println("main方法中#####：i="+i);
        }
    }
}

输出结果为：

run方法中：i=1
run方法中：i=2
run方法中：i=3
run方法中：i=4
run方法中：i=5
run方法中：i=6
run方法中：i=7
run方法中：i=8
run方法中：i=9
run方法中：i=10
run方法中：i=11
run方法中：i=12
run方法中：i=13
run方法中：i=14
run方法中：i=15
run方法中：i=16
run方法中：i=17
run方法中：i=18
run方法中：i=19
main方法中#####：i=1
main方法中#####：i=2
main方法中#####：i=3
main方法中#####：i=4
main方法中#####：i=5
main方法中#####：i=6
main方法中#####：i=7
main方法中#####：i=8
main方法中#####：i=9
main方法中#####：i=10
main方法中#####：i=11
main方法中#####：i=12
main方法中#####：i=13
main方法中#####：i=14
main方法中#####：i=15
main方法中#####：i=16
main方法中#####：i=17
main方法中#####：i=18
main方法中#####：i=19

可见，run方法的代码执行完毕后才可以允许main方法中的run；
但是，我们注意到，有一句创建该类的对象调用start方法，因此我们改动一下：

package com.lagou.task08;

public class SubThreadRunTest {
    public static void main(String[] args) {
        //1.声明Thread类型的引用指向子类类型的对象
        Thread t1=new SubThreadRun();
        
        //用于启动线程，java虚拟机会自动调用该类线程类中的run方法
        //相当于又启动了一个线程，加上执行main方法的线程是两个线程
        t1.start();
        //打印1-20之间的所有整数
        for(int i=1;i<20;i++)
        {
            System.out.println("main方法中#####：i="+i);
        }
    }
}

输出结果为：

run方法中：i=1
main方法中#####：i=1
main方法中#####：i=2
run方法中：i=2
main方法中#####：i=3
run方法中：i=3
main方法中#####：i=4
main方法中#####：i=5
main方法中#####：i=6
run方法中：i=4
main方法中#####：i=7
run方法中：i=5
main方法中#####：i=8
run方法中：i=6
main方法中#####：i=9
run方法中：i=7
main方法中#####：i=10
run方法中：i=8
main方法中#####：i=11
run方法中：i=9
main方法中#####：i=12
run方法中：i=10
main方法中#####：i=13
run方法中：i=11
main方法中#####：i=14
run方法中：i=12
main方法中#####：i=15
run方法中：i=13
main方法中#####：i=16
run方法中：i=14
main方法中#####：i=17
run方法中：i=15
main方法中#####：i=18
run方法中：i=16
main方法中#####：i=19
run方法中：i=17
run方法中：i=18
run方法中：i=19

可见，main中的方法与run方法交错允许，并且每一次运行的结果并不是那么一致，这里，start方法相当于启动了另外一个线程，两个线程同时运行；
18.2.4 执行流程
执行main方法的线程叫做主线程，执行run方法的线程叫做新线程/子线程；
main方法是程序的入口，对于start方法之前的代码来说，由主线程执行一次，当start方法调用成功后线程的个数由1个变成了2个，新启动的线程去执行run方法的代码，主线程继续向下执行，两个线程各自独立运行互不影响；
当run方法执行完毕后子线程结束，当main方法执行完毕后主线程结束；
两个线程执行没有明确的先后执行次序，由操作系统调度算法来决定；
线程创建和启动的方式2：
可以继承Thread类，也可以越过Thread类直接找Runnable接口，但是因为start方法是Thread类中的方法，因此使用Thread类型的对象调用start方法；
接下来，我们完成一下相关代码：
首先定义一个类来重写Runnable接口中的方法：

package com.lagou.task08;

public class SubRunnableRun implements  Runnable{
    @Override
    public void run() {
        //打印1-20之间的所有整数
        for(int i=1;i<20;i++)
        {
            System.out.println("run方法：i="+i);
        }
    }
}

然后再定义一个类

package com.lagou.task08;

public class SubRunnableRunTest {
    public static void main(String[] args) {
        //1.创建自定义类型的对象，也就是实现Runable接口类的对象
        SubRunnableRun srr=new SubRunnableRun();
        //2.使用该对象作为实参构造Thread类型的对象
        //由源码可知：经过构造方法的调用之后，Thread类中的成员变量target的数值为srr
        Thread t1=new Thread(srr);
        //3.使用Thread类型的对象调用start方法
        //若使用Runnable引用构造了线程对象，调用该方法(run())时最终调用接口中的版本
        //由run方法的源码可知：if (target != null){ target.run(); }
        //此时target的数值不为空这个条件成立，执行target.run()的代码，也就是srr.run()的代码
        t1.start();


        //打印1-20之间的所有整数
        for(int i=1;i<20;i++)
        {
            System.out.println("main方法中#####：i="+i);
        }
    }
}

可见这个方法首先需要创建一个实现Runnable接口类的对象，然后再构造一个Thread类型的对象，再利用这个对象来调用start方法；
18.2.5 方式的比较
继承Thread类的方式代码简单，但是若该类继承Thread类后则无法继承其他类，而实现Runnable接口的方式代码复杂，但不影响该类继承其他类以及实现其它接口，因此以后的开发中推荐使用第二种方式；
18.2.6 匿名内部类的方式
下面我们使用匿名内部类的方式来创建和启动线程；
匿名内部类的语法格式：
父类/接口类型引用变量名=new 父类/接口类型()；
{ 方法的重写 }；
可以使用两种方法来定义匿名内部类：
//1.使用继承加匿名内部类的方式创建并启动线程
//2.使用实现接口加匿名内部类的方式创建并启动线程

package com.lagou.task08;

import java.sql.SQLOutput;

public class ThreadNoNameTest {
    public static void main(String[] args) {
        //匿名内部类的语法格式：父类/接口类型 引用变量名=new 父类/接口类型() {方法的重写};
        //1.使用继承加匿名内部类的方式创建并启动线程
        Thread t1=new Thread(){
            @Override
            public void run() {
                System.out.println("小桥流水桂花香，日夜千思万想");
            }
        };
        t1.start();
        //2.使用实现接口加匿名内部类的方式创建并启动线程
        Runnable ra=new Runnable() {
            @Override
            public void run() {
                System.out.println("大江东去浪淘尽，千古风流人物");
            }
        };
        Thread t2=new Thread(ra);
        t2.start();

    }
}

输出结果为：
小桥流水桂花香，日夜千思万想
大江东去浪淘尽，千古风流人物
下面我们可以把代码进行优化嗷：

package com.lagou.task08;

import java.sql.SQLOutput;

public class ThreadNoNameTest {
    public static void main(String[] args) {
        //匿名内部类的语法格式：父类/接口类型 引用变量名=new 父类/接口类型() {方法的重写};
        //1.使用继承加匿名内部类的方式创建并启动线程
//        Thread t1=new Thread(){
//            @Override
//            public void run() {
//                System.out.println("小桥流水桂花香，日夜千思万想");
//            }
//        };
//        t1.start();

        new Thread(){
            @Override
            public void run() {
                System.out.println("小桥流水桂花香，日夜千思万想");
            }
        }.start();

        //2.使用实现接口加匿名内部类的方式创建并启动线程
//        Runnable ra=new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("大江东去浪淘尽，千古风流人物");
//            }
//        };
//        Thread t2=new Thread(ra);
//        t2.start();

        /*new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("大江东去浪淘尽，千古风流人物");
            }
        }).start();*/

        //java8开始支持lambda表达式：()->{方法体;}
        /*Runnable ra=()-> System.out.println("大江东去浪淘尽，千古风流人物");
        new Thread(ra).start();*/
        
        new Thread(()-> System.out.println("大江东去浪淘尽，千古风流人物")).start();
    }
}

里面写了很多版本的代码，值得认真观看；
18.3 线程的生命周期
在这里插入图片描述
新建状态：使用new关键字创建之后进入的状态，此时线程并没有开始执行；
就绪状态：调用start方法后进入的状态，此时线程还是没有开始执行；
运行状态：使用线程调度器调用该线程后进入的状态，此时线程开始执行，当线程的时间片执行完毕后任务没有完成时回到就绪状态（箭头双向）；
消亡状态：当线程的任务执行完成后进入的状态，此时线程已经终止；
阻塞状态：当线程执行的过程中发生了阻塞事件进入的状态，如：sleep方法；
阻塞状态解除后进入就绪状态；
18.4 线程的编号和名称（熟悉）

方法声明	功能介绍
long getId()	获取调用对象所表示线程的编号
String getName()	获取调用对象所表示线程的名称
void setName(String name)	设置/修改线程的名称为参数指定的数值
static Thread currentThread()	获取正在执行线程的引用

线程ID无法随意设置；
案例题目：
自定义类继承Thread类并且重写run方法，在run方法中打印当前线程的编号和名称，然后将线程的名称修改为"zhangfei"后再次打印编号和名称；
要求在main方法中也要打印主线程的编号和名称；

package com.lagou.task08;

public class ThreadIdNameTest extends Thread{
    @Override
    public void run() {
        System.out.println("子线程的编号是："+getId()+"，名称是："+getName());
    }

    public static void main(String[] args) {
        ThreadIdNameTest tint=new ThreadIdNameTest();
        tint.start();
    }
}

输出结果为：子线程的编号是：14，名称是：Thread-0
下面对代码进行修改实现案例题目：

package com.lagou.task08;

public class ThreadIdNameTest extends Thread{

    public ThreadIdNameTest(String name) {
        super(name);  //表示调用父类的构造方法
    }

    @Override
    public void run() {
        System.out.println("子线程的编号是："+getId()+"，名称是："+getName());  //  14 Thread-0 guanyu
        //修改名称为"zhangfei"
        setName("zhangfei");
        System.out.println("修改后子线程的编号是："+getId()+"，名称是："+getName());  //  14 zhangfei
    }

    public static void main(String[] args) {
        ThreadIdNameTest tint=new ThreadIdNameTest("guanyu");
        tint.start();

        //获取当前正在执行线程的引用，当前正在执行的是主线程，也就是获取主线程的引用
        Thread t1=Thread.currentThread();
        System.out.println("主线程的编号是："+t1.getId()+"，名称是："+t1.getName());
    }
}

输出结果为：
主线程的编号是：1，名称是：main
子线程的编号是：14，名称是：guanyu
修改后子线程的编号是：14，名称是：zhangfei
下面代码表示利用接口来实现上述案例题目：

package com.lagou.task08;

public class RunnableIdNameTest implements Runnable{
    @Override
    public void run() {
        //获取当前执行线程的引用，也就是子线程的引用
        Thread t1=Thread.currentThread();
        System.out.println("子线程的编号是："+t1.getId()+"，名称是："+t1.getName()); //14 guanyu
        t1.setName("zhangfei");
        System.out.println("修改后子线程的编号是："+t1.getId()+"名称是："+t1.getName()); //14 zhangfei
    }

    public static void main(String[] args) {
        RunnableIdNameTest rint=new RunnableIdNameTest();
        //Thread t2=new Thread(rint);
        Thread t2=new Thread(rint,"guanyu");
        t2.start();

        //获取当前正在执行的线程的引用，当前正在执行的线程是主线程，也就是获得主线程的引用
        Thread t1=Thread.currentThread();
        System.out.println("主线程的编号是："+t1.getId()+"，名称是："+t1.getName());
    }
}

输出结果为：
主线程的编号是：1，名称是：main
子线程的编号是：14，名称是：guanyu
修改后子线程的编号是：14名称是：zhangfei
18.5 常用的方法（重点）

方法声明	功能介绍
static void yield()	当前线程让出处理器(离开Running状态)，使当前线程进入Runnable状态等待
static void sleep(times)	使当前线程从Running放弃处理器进入Blocking状态，休眠times毫秒，再返回到Runnable，如果其他线程打断当前线程的Block(sleep)，就会发生InterruptedException
int getPriority	获取线程的优先级
void setPriority(int newPriority)	修改线程的优先级。< br/>；优先级越高的线程不一定先执行，但该线程获取到时间片的机会会更多一些
void join()	等待该线程终止
void join(long mills)	等待参数指定的毫秒数
boolean isDaemon()	用于判断是否为守护线程
void setDaemon(boolean on)	用于设置线程为守护线程

下面用代码说明有关sleep方法的引用：

package com.lagou.task08;

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

public class ThreadSleepTest extends Thread{

    private boolean flag=true;

    @Override
    public void run() {
        //声明一个布尔类型的变量作为循环是否执行的条件
        //每隔一秒获取一次系统时间并打印，模拟时钟的效果
        while(flag){
            //获取当前系统时间并调整格式打印
//            LocalDateTime.now();
            Date d1=new Date();
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(sdf.format(d1));

            //随眠一秒钟
            try {
                Thread.sleep(1000);  //为什么不能抛出，因为子类中重写的方法不能抛出更大的异常
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        ThreadSleepTest tst=new ThreadSleepTest();
        tst.start();

        //主线程等待5秒后结束子线程
        System.out.println("主线程开始等待.....");
        try {
            Thread.sleep(1000);
            System.out.println("1秒");
            Thread.sleep(1000);
            System.out.println("2秒");
            Thread.sleep(1000);
            System.out.println("3秒");
            Thread.sleep(1000);
            System.out.println("4秒");
            Thread.sleep(1000);
            System.out.println("5秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //停止子线程 stop过时 不建议使用
        //tst.stop();
        tst.flag=false;
        System.out.println("主线程等待结束！");
    }
}

输出结果为：
主线程开始等待…
2020-05-26 09:24:15
1秒
2020-05-26 09:24:16
2秒
2020-05-26 09:24:17
3秒
2020-05-26 09:24:18
4秒
2020-05-26 09:24:19
5秒
主线程等待结束！
线程优先级的管理：
要注意：优先级越高的线程不一定先执行，但机会更多

package com.lagou.task08;

public class ThreadPriorityTest extends Thread{

    @Override
    public void run() {
        //System.out.println("子线程的优先级："+getPriority());
        for(int i=0;i<20;i++)
        {
            System.out.println("子线程中：i="+i);
        }
    }

    public static void main(String[] args) {
        ThreadPriorityTest tpt=new ThreadPriorityTest();
        //设置子线程的优先级
        tpt.setPriority(Thread.MAX_PRIORITY);
        tpt.start();

        Thread t1=Thread.currentThread();
        //System.out.println("主线程的优先级是："+t1.getPriority());
        for(int i=0;i<20;i++)
        {
            System.out.println("主线程中######：i="+i);
        }
    }
}

输出结果为：

子线程中：i=0
主线程中######：i=0
主线程中######：i=1
子线程中：i=1
主线程中######：i=2
子线程中：i=2
主线程中######：i=3
子线程中：i=3
主线程中######：i=4
子线程中：i=4
主线程中######：i=5
子线程中：i=5
主线程中######：i=6
主线程中######：i=7
主线程中######：i=8
主线程中######：i=9
子线程中：i=6
主线程中######：i=10
主线程中######：i=11
子线程中：i=7
主线程中######：i=12
主线程中######：i=13
子线程中：i=8
主线程中######：i=14
主线程中######：i=15
主线程中######：i=16
主线程中######：i=17
子线程中：i=9
主线程中######：i=18
子线程中：i=10
主线程中######：i=19
子线程中：i=11
子线程中：i=12
子线程中：i=13
子线程中：i=14
子线程中：i=15
子线程中：i=16
子线程中：i=17
子线程中：i=18
子线程中：i=19

线程的等待：join()

package com.lagou.task08;

public class ThreadJoinTest extends Thread{
    @Override
    public void run() {
        //模拟倒数十个数的效果
        System.out.println("倒计时开始。。。");
        for(int i=10;i>0;i--)
        {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("新年快乐");
    }

    public static void main(String[] args) {
        ThreadJoinTest tjt=new ThreadJoinTest();
        tjt.start();

        //主线程开始等待
        System.out.println("主线程开始等待");
        try {
            //表示当前正在执行的线程对象等待调用线程对象，也就是主线程等待子线程终止
            //tjt.join();
            tjt.join(5000); //最多等待5秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("可惜不是你！");
    }
}

输出结果为：

主线程开始等待
倒计时开始。。。
10
9
8
7
6
可惜不是你！
5
4
3
2
1
新年快乐

守护线程：
setDaemon方法注意：必须在Thread开始之前调用；

package com.lagou.task08;

public class ThreadDaemonTest extends Thread{
    @Override
    public void run() {
        //System.out.println(isDaemon()?"该线程是守护线程":"该线程不是守护线程"); //默认不是守护线程
        //当子线程不是守护线程时，虽然主线先结束了，但是子线程依然会继续执行，直到打印完毕所有数据为止
        //当子线程是守护线程时，当主线程结束后，则子线程随之结束，踩刹车需要时间
        //开发中如果需要主线程结束后子线程也随之结束，那么就设置子线程为守护线程
        for (int i = 0; i < 50; i++) {
            System.out.println("子线程中：i="+i);
        }
    }

    public static void main(String[] args) {
        ThreadDaemonTest tdt=new ThreadDaemonTest();
        //必须在线程启动之前设置子线程为守护线程
        tdt.setDaemon(true);
        tdt.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程中######："+i);
        }
    }
}

输出结果为：

子线程中：i=0
主线程中######：0
子线程中：i=1
主线程中######：1
子线程中：i=2
主线程中######：2
子线程中：i=3
主线程中######：3
子线程中：i=4
主线程中######：4
子线程中：i=5
主线程中######：5
子线程中：i=6
主线程中######：6
子线程中：i=7
主线程中######：7
主线程中######：8
主线程中######：9
主线程中######：10
主线程中######：11
子线程中：i=8
主线程中######：12
子线程中：i=9
子线程中：i=10
子线程中：i=11
子线程中：i=12
子线程中：i=13
子线程中：i=14
子线程中：i=15
子线程中：i=16
主线程中######：13
子线程中：i=17
主线程中######：14
子线程中：i=18
主线程中######：15
子线程中：i=19
主线程中######：16
子线程中：i=20
主线程中######：17
子线程中：i=21
主线程中######：18
子线程中：i=22
主线程中######：19
子线程中：i=23
子线程中：i=24
子线程中：i=25
子线程中：i=26
子线程中：i=27
子线程中：i=28
子线程中：i=29
子线程中：i=30
子线程中：i=31
子线程中：i=32
子线程中：i=33
子线程中：i=34
子线程中：i=35
子线程中：i=36
子线程中：i=37
子线程中：i=38
子线程中：i=39
子线程中：i=40
子线程中：i=41
子线程中：i=42
子线程中：i=43
子线程中：i=44

案例题目：
编程创建两个线程，线程一负责打印1-100之间的所有奇数，其中线程二负责打印1-100之间的所有偶数，在main方法启动上述两个线程同时执行，主线程等待两个线程终止；
第一个方法很简单，两个类加一个主函数：
第一个类打印奇数：

package com.lagou.task08;

public class SubThread1 extends Thread {
    @Override
    public void run() {
        //打印1-50之间的所有奇数
        for (int i = 1; i < 50; i+=2) {
            System.out.println("子线程一中：i="+i);
        }
    }
}

第二个类打印偶数：

package com.lagou.task08;

public class SubThread2 extends Thread{
    @Override
    public void run() {
        //打印1-100之间的所有偶数
        for (int i = 2; i <= 50; i+=2) {
            System.out.println("子线程二中#####：i="+i);
        }
    }
}

第三个为主函数

package com.lagou.task08;

public class SubThreadTest {
    public static void main(String[] args) {
        SubThread1 st1=new SubThread1();
        SubThread2 st2=new SubThread2();

        st1.start();
        st2.start();

        System.out.println("主线程开始等待。。。");
        try {
            st1.join();
            st2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程等待结束！");
    }
}

输出结果为：

主线程开始等待。。。
子线程一中：i=1
子线程二中#####：i=2
子线程一中：i=3
子线程二中#####：i=4
子线程一中：i=5
子线程二中#####：i=6
子线程一中：i=7
子线程二中#####：i=8
子线程一中：i=9
子线程二中#####：i=10
子线程一中：i=11
子线程二中#####：i=12
子线程一中：i=13
子线程二中#####：i=14
子线程一中：i=15
子线程二中#####：i=16
子线程一中：i=17
子线程二中#####：i=18
子线程一中：i=19
子线程二中#####：i=20
子线程一中：i=21
子线程二中#####：i=22
子线程一中：i=23
子线程二中#####：i=24
子线程一中：i=25
子线程二中#####：i=26
子线程一中：i=27
子线程二中#####：i=28
子线程二中#####：i=30
子线程一中：i=29
子线程二中#####：i=32
子线程一中：i=31
子线程二中#####：i=34
子线程一中：i=33
子线程二中#####：i=36
子线程一中：i=35
子线程二中#####：i=38
子线程一中：i=37
子线程二中#####：i=40
子线程一中：i=39
子线程二中#####：i=42
子线程一中：i=41
子线程二中#####：i=44
子线程一中：i=43
子线程二中#####：i=46
子线程一中：i=45
子线程二中#####：i=48
子线程一中：i=47
子线程一中：i=49
子线程二中#####：i=50
主线程等待结束！

下面我们用Runnable接口实现上述功能：

package com.lagou.task08;

public class SubRunnable1 implements Runnable{

    @Override
    public void run() {
        //打印1-50之间的所有奇数
        for (int i = 1; i < 50; i+=2) {
            System.out.println("子线程一中：i="+i);
        }
    }
}

package com.lagou.task08;

public class SubRunnable2 implements Runnable{
    @Override
    public void run() {
        //打印1-50之间的所有偶数
        for (int i = 2; i <= 50; i+=2) {
            System.out.println("子线程二中#####：i="+i);
        }
    }
}

package com.lagou.task08;

public class SubRunnableTest {
    public static void main(String[] args) {
        SubRunnable1 s1=new SubRunnable1();
        SubRunnable2 s2=new SubRunnable2();

        Thread t1=new Thread(s1);
        Thread t2=new Thread(s2);

        t1.start();
        t2.start();

        System.out.println("主线程开始等待。。。");
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程等待结束！");
    }
}

输出结果与上述一致；
18.6 线程同步机制（重点）
18.6.1 基本概念
当多个线程同时访问同一种共享资源时，可能造成数据的覆盖等不一致性问题，此时就需要对线程之间进行通信和协调，该机制就叫做线程的同步机制；
多个线程并发读写同一个临界资源时会发生线程并发安全问题；
异步操作：多线程并发的操作，各自独立运行；
同步操作：多线程串行的操作，先后执行的顺序；
我们通过取钱的案例来解释它：

package com.lagou.task08;

public class AccountRunnableTest implements Runnable{
    private int balance; //用于描述账户的余额

    public AccountRunnableTest(){

    }

    public AccountRunnableTest(int balance) {
        this.balance = balance;
    }

    public int getBalance(){
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public void run() {
        //1.模拟从后台从后台查询账户余额的过程
        int temp=getBalance();
        //2.模拟取款200元的过程
        if(temp>=200){
            System.out.println("正在出钞，请稍后。。。");
            temp-=200;
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("请取走您的钞票！");
        }
        else
        {
            System.out.println("余额不足，请核对您的账户余额！");
        }
        //3.模拟将最新的账户余额写入到后台
        setBalance(temp);

    }

    public static void main(String[] args) {
        AccountRunnableTest account=new AccountRunnableTest(1000);
        Thread t1=new Thread(account);
        Thread t2=new Thread(account);

        t1.start();
        t2.start();

        System.out.println("主线程开始等待。。。");
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("最终的账户余额为："+account.getBalance()); //800
    }
}

输出结果为：
主线程开始等待。。。
正在出钞，请稍后。。。
正在出钞，请稍后。。。
请取走您的钞票！
请取走您的钞票！
最终的账户余额为：800
可见，多线程同时执行时就发生了错误，因此需要对其进行改进：
18.6.2 解决方案
由程序结果可知：当两个线程同时对同一个账户进行取款时，导致最终的账户余额不合理；
引发原因：线程一执行取款时还没有来得及将取款后的金额写入后台，线程二就已经开始取款；
解决方案：让线程一执行完毕取款操作后，再让线程二执行即可，将线程的并发操作改为串行操作；
经验分享：在以后的开发尽量减少串行操作的范围，从而提高效率；
18.6.3 实现方式
在java语言中使用synchronized关键字来实现同步/对象锁机制从而保证线程执行的原子性（最小单位，不能再切割），具体方式如下：
要么不执行，要不执行完，执行的过程中不能打断
使用同步代码的方式实现部分代码的锁定，格式如下：

synchronized(类类型的引用){
	编写所有需要锁定的代码；
}

使用同步方法的方式实现所有代码的锁定。
直接使用synchronized关键字来修饰整个方法即可；
该方法等价于：

synchronized(this){整个方法体的代码}

修改后的代码如下：

package com.lagou.task08;

public class AccountRunnableTest implements Runnable{
    private int balance; //用于描述账户的余额
    private Demo dm=new Demo();
    public AccountRunnableTest(){

    }

    public AccountRunnableTest(int balance) {
        this.balance = balance;
    }

    public int getBalance(){
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public void run() {
        System.out.println("线程"+Thread.currentThread().getName()+"已启动...");
        synchronized (dm) {
            //1.模拟从后台从后台查询账户余额的过程
            int temp=getBalance();
            //2.模拟取款200元的过程
            if(temp>=200){
                System.out.println("正在出钞，请稍后。。。");
                temp-=200;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            }
            else
            {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            //3.模拟将最新的账户余额写入到后台
            setBalance(temp);
        }

    }

    public static void main(String[] args) {
        AccountRunnableTest account=new AccountRunnableTest(1000);
        Thread t1=new Thread(account);
        Thread t2=new Thread(account);

        t1.start();
        t2.start();

        System.out.println("主线程开始等待。。。");
        try {
            t1.join();
            //t2.start(); //也就是等待线程一取款操作结束后再启动线程二 但是这样多线程意义失去
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("最终的账户余额为："+account.getBalance());
    }
}

class Demo{}

输出结果为：
主线程开始等待。。。
线程Thread-1已启动…
线程Thread-0已启动…
正在出钞，请稍后。。。
请取走您的钞票！
正在出钞，请稍后。。。
请取走您的钞票！
最终的账户余额为：600
上述方法为实现Runnable接口的方式，同样，可以使用继承Thread类的方式实现它：

package com.lagou.task08;

public class AccountThreadTest extends Thread{
    private int balance; //用于描述账户的余额
    private static Demo dm=new Demo();  //隶属于类层级，所有对象共享同一个
    public AccountThreadTest(){

    }

    public AccountThreadTest(int balance) {
        this.balance = balance;
    }

    public int getBalance(){
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public void run() {
        System.out.println("线程"+Thread.currentThread().getName()+"已启动...");
        synchronized (dm) {
            //1.模拟从后台从后台查询账户余额的过程
            int temp=getBalance();
            //2.模拟取款200元的过程
            if(temp>=200){
                System.out.println("正在出钞，请稍后。。。");
                temp-=200;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            }
            else
            {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            //3.模拟将最新的账户余额写入到后台
            setBalance(temp);
        }

    }

    public static void main(String[] args) {
        AccountThreadTest att1=new AccountThreadTest(1000);
        att1.start();

        AccountThreadTest att2=new AccountThreadTest(1000);
        att2.start();

        System.out.println("主线程开始等待。。。");
        try {
            att1.join();
            att2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("最终的账户余额为："+att1.getBalance());
    }
}

输出结果为：

主线程开始等待。。。
线程Thread-0已启动...
线程Thread-1已启动...
正在出钞，请稍后。。。
请取走您的钞票！
正在出钞，请稍后。。。
请取走您的钞票！
最终的账户余额为：800

上面加入了static关键字的使用；
下面是第二种–同步方法实现线程同步的两种方式：

package com.lagou.task08;

public class AccountRunnableTest implements Runnable{
    private int balance; //用于描述账户的余额
    private Demo dm=new Demo();
    public AccountRunnableTest(){

    }

    public AccountRunnableTest(int balance) {
        this.balance = balance;
    }

    public int getBalance(){
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public /*synchronized*/ void run() {
        //由源码可知：最终是account对象来调用run方法，因此当前正在调用的对象就是account，也就是说this就是account
        synchronized (this){
        System.out.println("线程"+Thread.currentThread().getName()+"已启动...");
        //synchronized (dm) {
            //1.模拟从后台从后台查询账户余额的过程
            int temp=getBalance();
            //2.模拟取款200元的过程
            if(temp>=200){
                System.out.println("正在出钞，请稍后。。。");
                temp-=200;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            }
            else
            {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            //3.模拟将最新的账户余额写入到后台
            setBalance(temp);
        }

    }

    public static void main(String[] args) {
        AccountRunnableTest account=new AccountRunnableTest(1000);
        Thread t1=new Thread(account);
        Thread t2=new Thread(account);

        t1.start();
        t2.start();

        System.out.println("主线程开始等待。。。");
        try {
            t1.join();
            //t2.start(); //也就是等待线程一取款操作结束后再启动线程二 但是这样多线程意义失去
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("最终的账户余额为："+account.getBalance());
    }
}

class Demo{}

第二种方式：

package com.lagou.task08;

public class AccountThreadTest02 extends Thread{
    private int balance; //用于描述账户的余额
    private static Demo dm=new Demo();  //隶属于类层级，所有对象共享同一个
    public AccountThreadTest02(){

    }

    public AccountThreadTest02(int balance) {
        this.balance = balance;
    }

    public int getBalance(){
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public void run() {

        test();

    }

    public /*synchronized*/ static void test(){
        synchronized (AccountThreadTest02.class){  //类名点class表示该类型对应的class对象，由于类型是固定的，因此class对象也是唯一的，因此可以实现同步
        System.out.println("线程"+Thread.currentThread().getName()+"已启动...");
        //synchronized (dm) {
            //1.模拟从后台从后台查询账户余额的过程
            int temp=1000;    //getBalance();
            //2.模拟取款200元的过程
            if(temp>=200){
                System.out.println("正在出钞，请稍后。。。");
                temp-=200;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            }
            else
            {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            //3.模拟将最新的账户余额写入到后台
            //setBalance(temp);
        }
    }

    public static void main(String[] args) {
        AccountThreadTest02 att1=new AccountThreadTest02(1000);
        att1.start();

        AccountThreadTest02 att2=new AccountThreadTest02(1000);
        att2.start();

        System.out.println("主线程开始等待。。。");
        try {
            att1.join();
            att2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("最终的账户余额为："+att1.getBalance());
    }
}

18.6.5 注意事项
使用synchronized保证线程同步应当注意：
多个需要同步的线程在访问同步块时，看到的应该是同一个锁对象引用（同一个对象才能锁得住）；
在使用同步块时应当尽量减少同步范围以提高并发的执行效率；
18.6.6 线程安全类和不安全类
StringBuffer类是线程安全的类，但StringBuilder类不是线程安全的类；
Vector类和HashTable类是线程安全的类，但ArrayList类和HashMap类不是线程安全的类；
Collections.synchronizedList()和Collections.synchronizedMap()等方法实现将非线程安全的类转为安全的类；
18.6.7 死锁的概念
线程一执行的代码：

public void run(){
	synchronized(a){  //持有对象锁a，等待对象锁b
		synchronized(b){
			编写锁定的代码;
		}
	}
}

线程二执行的代码：

public void run(){
	synchronized(b){  //持有对象锁b，等待对象锁a
		synchronized(a){
			编写锁定的代码;
		}
	}
}

注意：
在以后的开发中尽量减少同步的资源，减少同步代码块的嵌套结构的使用！
18.6.8 使用Lock（锁）实现线程同步
(1) 基本概念
从java5开始提供了更强大的线程同步机制==》使用显式定义的同步锁对象来实现；
从java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具；
该接口的主要实现类是ReentrantLock，该类拥有与synchronized相同的并发性，在以后的线程安全控制中，经常使用ReentrantLock类显式加锁和释放锁；
(2) 常用的方法

方法声明	功能介绍
ReentrantLock	使用无参方式构造对象
void lock()	获取锁
void unlock()	释放锁

(3) 与synchronized方式的比较
Lock是显式锁，需要手动实现开启和关闭操作，而synchronized是隐式锁，执行锁定代码后自动释放；
Lock只有同步代码块方式的锁，而synchronized有同步代码块方式和同步方法两种锁；
使用Lock锁方式时，java虚拟机将花费较少的时间来调度线程，因此性能更好；
下面利用代码来展示一下lock方法：

package com.lagou.task08;

import java.util.concurrent.locks.ReentrantLock;

public class AccountRunnableTest implements Runnable{
    private int balance; //用于描述账户的余额
    private Demo dm=new Demo();
    private ReentrantLock lock=new ReentrantLock();  //准备了一把锁
    public AccountRunnableTest(){

    }

    public AccountRunnableTest(int balance) {
        this.balance = balance;
    }

    public int getBalance(){
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public /*synchronized*/ void run() {
        //由源码可知：最终是account对象来调用run方法，因此当前正在调用的对象就是account，也就是说this就是account
//        synchronized (this){
        //开始加锁
        lock.lock();
        System.out.println("线程"+Thread.currentThread().getName()+"已启动...");
        //synchronized (dm) {
            //1.模拟从后台从后台查询账户余额的过程
            int temp=getBalance();
            //2.模拟取款200元的过程
            if(temp>=200){
                System.out.println("正在出钞，请稍后。。。");
                temp-=200;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            }
            else
            {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            //3.模拟将最新的账户余额写入到后台
            setBalance(temp);
//        }
        lock.unlock();

    }

    public static void main(String[] args) {
        AccountRunnableTest account=new AccountRunnableTest(1000);
        Thread t1=new Thread(account);
        Thread t2=new Thread(account);

        t1.start();
        t2.start();

        System.out.println("主线程开始等待。。。");
        try {
            t1.join();
            //t2.start(); //也就是等待线程一取款操作结束后再启动线程二 但是这样多线程意义失去
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("最终的账户余额为："+account.getBalance());
    }
}

class Demo{}

18.6.9 Object类常用的方法

方法声明	功能介绍
void wait()	用于使得线程进入等待状态，直到其他线程调用notify()或notifyAll()方法
void wait(long timeout)	用于进入等待状态，直到其他线程调用方法或参数指定的毫秒数已经过去为止
void notify()	用于唤醒等待的单个线程
void notifyAll()	用于唤醒等待的所有线程

这四个方法主要实现线程与线程之间交互；
下面我们用代码来一个功能，线程一与线程二来回切换打印1-100之间的整数；

package com.lagou.task08;

public class ThreadCommunicateTest implements Runnable{
    private int cnt=1;
    @Override
    public void run() {
        while(true)
        {
            synchronized (this) {
                //每当有一个线程进来后先大喊一声，调用notify方法
                notify();
                if(cnt<=100)
                {
                    System.out.println("线程"+Thread.currentThread().getName()+"中：cnt="+cnt);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    cnt++;
                    //当前线程打印完毕一个整数后，为了防止继续打印下一个数据，则调用wait方法
                    try {
                        wait(); //当前线程进入阻塞状态，自动释放对象锁，必须在锁定的代码中调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else
                {
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        ThreadCommunicateTest tct=new ThreadCommunicateTest();
        Thread t1=new Thread(tct);
        t1.start();

        Thread t2=new Thread(tct);
        t2.start();
    }
}

输出结果为：

线程Thread-0中：cnt=1
线程Thread-1中：cnt=2
线程Thread-0中：cnt=3
线程Thread-1中：cnt=4
线程Thread-0中：cnt=5
线程Thread-1中：cnt=6
线程Thread-0中：cnt=7
线程Thread-1中：cnt=8
线程Thread-0中：cnt=9
线程Thread-1中：cnt=10
线程Thread-0中：cnt=11
线程Thread-1中：cnt=12
线程Thread-0中：cnt=13
线程Thread-1中：cnt=14
线程Thread-0中：cnt=15
线程Thread-1中：cnt=16
线程Thread-0中：cnt=17
线程Thread-1中：cnt=18
线程Thread-0中：cnt=19
线程Thread-1中：cnt=20
线程Thread-0中：cnt=21
线程Thread-1中：cnt=22
线程Thread-0中：cnt=23
线程Thread-1中：cnt=24
线程Thread-0中：cnt=25
线程Thread-1中：cnt=26
线程Thread-0中：cnt=27
线程Thread-1中：cnt=28
线程Thread-0中：cnt=29
线程Thread-1中：cnt=30
线程Thread-0中：cnt=31
线程Thread-1中：cnt=32
线程Thread-0中：cnt=33
线程Thread-1中：cnt=34
线程Thread-0中：cnt=35
线程Thread-1中：cnt=36
线程Thread-0中：cnt=37
线程Thread-1中：cnt=38
线程Thread-0中：cnt=39
线程Thread-1中：cnt=40
线程Thread-0中：cnt=41
线程Thread-1中：cnt=42
线程Thread-0中：cnt=43
线程Thread-1中：cnt=44
线程Thread-0中：cnt=45
线程Thread-1中：cnt=46
线程Thread-0中：cnt=47
线程Thread-1中：cnt=48
线程Thread-0中：cnt=49
线程Thread-1中：cnt=50
线程Thread-0中：cnt=51
线程Thread-1中：cnt=52
线程Thread-0中：cnt=53
线程Thread-1中：cnt=54
线程Thread-0中：cnt=55
线程Thread-1中：cnt=56
线程Thread-0中：cnt=57
线程Thread-1中：cnt=58
线程Thread-0中：cnt=59
线程Thread-1中：cnt=60
线程Thread-0中：cnt=61
线程Thread-1中：cnt=62
线程Thread-0中：cnt=63
线程Thread-1中：cnt=64
线程Thread-0中：cnt=65
线程Thread-1中：cnt=66
线程Thread-0中：cnt=67
线程Thread-1中：cnt=68
线程Thread-0中：cnt=69
线程Thread-1中：cnt=70
线程Thread-0中：cnt=71
线程Thread-1中：cnt=72
线程Thread-0中：cnt=73
线程Thread-1中：cnt=74
线程Thread-0中：cnt=75
线程Thread-1中：cnt=76
线程Thread-0中：cnt=77
线程Thread-1中：cnt=78
线程Thread-0中：cnt=79
线程Thread-1中：cnt=80
线程Thread-0中：cnt=81
线程Thread-1中：cnt=82
线程Thread-0中：cnt=83
线程Thread-1中：cnt=84
线程Thread-0中：cnt=85
线程Thread-1中：cnt=86
线程Thread-0中：cnt=87
线程Thread-1中：cnt=88
线程Thread-0中：cnt=89
线程Thread-1中：cnt=90
线程Thread-0中：cnt=91
线程Thread-1中：cnt=92
线程Thread-0中：cnt=93
线程Thread-1中：cnt=94
线程Thread-0中：cnt=95
线程Thread-1中：cnt=96
线程Thread-0中：cnt=97
线程Thread-1中：cnt=98
线程Thread-0中：cnt=99
线程Thread-1中：cnt=100

生产者消费者模型：
在这里插入图片描述
首先编程实现仓库类：

package com.lagou.task08;

/**
 * 编程实现仓库类
 */
public class StoreHouse {

    private int cnt=0;  //用于记录产品的数量


    public synchronized void produceProduct() {
        notify();
        if(cnt<10)
        {
            System.out.println("线程"+Thread.currentThread().getName()+"正在生产第"+(cnt+1)+"个产品...");
            cnt++;
        }
        else
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumerProduct() {
        notify();
        if(cnt>0)
        {
            System.out.println("线程"+Thread.currentThread().getName()+"消费第"+cnt+"个产品");
            cnt--;
        }
        else
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

然后实现生产者类：

package com.lagou.task08;

/**
 * 编程实现生产者线程，不断的生产产品
 */
public class ProduceThread extends Thread{
    //声明一个仓库类型的引用作为成员变量，是为了能调用仓库类中的生产方法  合成复用原则
    private StoreHouse storeHouse;
    //为了确保两个线程共用同一个仓库
    public ProduceThread(StoreHouse storeHouse){
        this.storeHouse=storeHouse;
    }

    @Override
    public void run() {
        while(true){
            storeHouse.produceProduct();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

然后实现消费者类：

package com.lagou.task08;

public class ConsumerThread extends Thread{
    //声明一个仓库类型的引用作为成员变量，是为了能调用仓库类中的生产方法  合成复用原则
    private StoreHouse storeHouse;
    //为了确保两个线程共用同一个仓库
    public ConsumerThread(StoreHouse storeHouse){
        this.storeHouse=storeHouse;
    }

    @Override
    public void run() {
        while(true){
            storeHouse.consumerProduct();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

最后实现调用方法：

package com.lagou.task08;

public class StoreHouseTest {
    public static void main(String[] args) {
        //创建仓库类的对象
        StoreHouse storeHouse=new StoreHouse();
        //创建线程类对象并启动
        ProduceThread t1=new ProduceThread(storeHouse);
        ConsumerThread t2=new ConsumerThread(storeHouse);
        t1.start();
        t2.start();
    }
}

输出结果如下：

线程Thread-0正在生产第1个产品...
线程Thread-1消费第1个产品
线程Thread-0正在生产第1个产品...
线程Thread-0正在生产第2个产品...
线程Thread-0正在生产第3个产品...
线程Thread-0正在生产第4个产品...
线程Thread-0正在生产第5个产品...
线程Thread-0正在生产第6个产品...
线程Thread-0正在生产第7个产品...
线程Thread-0正在生产第8个产品...
线程Thread-0正在生产第9个产品...
线程Thread-1消费第9个产品
线程Thread-0正在生产第9个产品...
线程Thread-0正在生产第10个产品...
线程Thread-1消费第10个产品
线程Thread-0正在生产第10个产品...

创建和启动线程的方式三：
18.6.10 线程池（熟悉）
(1) 实现Callable接口
从Java5开始新增加创建线程的第三种方式为实现Java.util.concurrent.Callable接口；
常用的方法如下：

方法声明	功能介绍
V call()	计算结果并返回

有返回值，v代表支持泛型；
(2) FutureTask类
Java.util.concurrent.FutureTask类用于描述可取消的异步计算，该类提供了Future接口的基本实现，包括启动和取消计算、查询计算是否完成以及检索计算结果的方法，也可以用于获取方法调用后的返回结果；
常用的方法如下：

方法声明	功能介绍
FutureTask(Callable< V > callable)	根据参数指定的引用来创建一个未来任务
V get()	获取call方法计算的结果

下面用代码来展示一下是如何启动线程的：

package com.lagou.task08;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadCallableTest implements Callable {

    @Override
    public Object call() throws Exception {
        //计算1-10000之间的累加和并打印返回
        int sum=0;
        for (int i = 1; i <=10000; i++) {
            sum +=i;
        }
        System.out.println("计算的累加和是："+sum);
        return sum;
    }

    public static void main(String[] args) {
        ThreadCallableTest tct=new ThreadCallableTest();
        FutureTask ft=new FutureTask(tct);
        Thread t1=new Thread(ft);
        t1.start();
        Object obj=null;
        try {
            obj=ft.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("线程处理方法的返回值是："+obj);
    }
}

输出结果为：
计算的累加和是：50005000
线程处理方法的返回值是：50005000
(3) 线程池的由来
在服务器编程模型的原理，每一个客户端连接用一个单独的线程为之服务，当与客户端的会话结束时，线程也就结束了，即每来一个客户端连接，服务器就要创建一个新线程；
如果访问服务器的客户端很多，那么服务器要不断的创建和销毁线程，这将严重的影响服务器的性能；
(4) 概念和原理
线程池的概念：首先创建一些线程，它们的集合称为线程池，当服务器接收到一个用户请求后，就从线程池中取出一个空闲的线程为之服务，服务完后不关闭线程，而是将该线程还回到线程池中；
在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，再把任务交给内部某个空闲的线程，任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务；
(5) 相关类和方法
从Java5开始提供了线程池的相关类和接口：Java.util.concurrent.Executors类和Java.util.concurrent.ExecutorService接口；
其中Executors是个工具类和线程池的工厂类，可以创建并返回不同类型的线程池，常用方法如下：

方法声明	功能介绍
static ExecutorService newCachedThreadPool()	创建一个可根据需要创建新线程的线程池
static ExecutorService newFixedThreadPool(int nThreads)	创建一个可重用固定线程数的线程池
static ExecutorService newSingleThreadExecutor()	创建一个只有一个线程的线程池

其中ExecutorService接口是真正的线程池接口，主要实现类是ThreadPoolExecutor，常用方法如下：

方法声明	功能介绍
void execute(Runnable command)	执行任务和命令，通常用于执行Runnable
< T >Future< T > submit(Callable< T>task)	执行任务和命令，通常用于执行Callable
void shutdown()	启动有序关闭

下面用代码来解释一下：

package com.lagou.task08;

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

public class ThreadPoolTest {
    public static void main(String[] args) {

        //1.创建一个线程池
        ExecutorService executorService= Executors.newFixedThreadPool(10);
        //2.向线程池中布置任务
        executorService.submit(new ThreadCallableTest());
        //3.关闭线程池
        executorService.shutdown();
    }
}

憨憨老婆伍

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LAGOU18 多线程

18.1.1 程序和进程的概念程序：数据结构+算法，主要是指存放在硬盘上的可执行文件；进程：主要是指运行在内存中的可执行文件；可执行文件放着叫程序，在内存中运行起来了就叫进程；目前主流的操作系统都支持多进程，为了让操作系统同时可以执行多个任务，但进程是重量级的，也就是新建一个进程会消耗CPU和内存空间等系统资源，因此进程的数量比较局限；18.1.2 线程的概念为了解决上述问题就提出线程的概念，线程就是进程内部的程序流，也就是说操作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是
复制链接

扫一扫