Java的多线程

Java的多线程

1.多线程概述

1.1.进程与线程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。

线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程最少有一个线程。

​ 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

1.2.线程调度

分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度：

• 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
• CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3.同步与异步

同步:排队执行 , 效率低但是安全.

所有的操作都做完，才返回给用户。这样用户在线等待的时间太长，给用户一种卡死了的感觉（就是系统迁移中，点击了迁移，界面就不动了，但是程序还在执行，卡死了的感觉）。这种情况下，用户不能关闭界面，如果关闭了，即迁移程序就中断了

异步:同时执行 , 效率高但是数据不安全.

将用户请求放入消息队列，并反馈给用户，系统迁移程序已经启动，你可以关闭浏览器了。然后程序再慢慢地去写入数据库去。这就是异步。但是用户没有卡死的感觉，会告诉你，你的请求系统已经响应了。你可以关闭界面了。

1.4.并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

2.线程的六种状态

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

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

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

WAITING：无限期等待另一个线程执行特定操作的线程处于此状态。

TIMED_WAITING：正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。

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

线程在给定时间点只能处于一种状态。 这些状态是虚拟机状态，不反映任何操作系统线程状态。

3.继承Thread

public class Demo1 {
    public static void main(String[] args) {
        //Thread
        //每个线程都有自己的栈空间，共用一份堆内存
        MyThread m = new MyThread();
        m.start();
        for(int i=0;i<10;i++){
            System.out.println("汗滴禾下土"+i);
        }
    }
}

public class MyThread extends Thread{
    /**
     * run方法就是线程要执行的任务方法
     */
    @Override
    public void run() {
        //这里的代码，就是一条新的路径
        //这个执行路径的触发方式，不是调用run方法，而是通过thread对象的start()来启动任务
        for(int i=0;i<10;i++){
            System.out.println("锄禾日当午"+i);
        }
    }
}

Thread类的常用方法：

变量和类型	方法	描述
long	getId()	返回此Thread的标识符。
String	getName()	返回此线程的名称。
int	getPriority()	返回此线程的优先级。
void	interrupt()	中断此线程。
boolean	isDaemon()	测试此线程是否为守护程序线程。
void	join(long millis)	此线程最多等待 millis毫秒。
void	run()	如果此线程是使用单独的Runnable运行对象构造的，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回。
static void	sleep(long millis)	导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。
void	start()	导致此线程开始执行; Java虚拟机调用此线程的run方法。

4.实现Runnable

实现Runnable与继承Thread相比有如下优势：

1.通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况

2，可以避免单继承所带来的局限性

3，任务与线程是分离的，提高了程序的健壮性

4，后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

public class Demo1 {
    //匿名内部类 实现多线程执行
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    System.out.println("一二三四五"+i);
                }
            }
        }.start();
        for (int i=0;i<10;i++){
            System.out.println("六七八九十"+i);
        }
    }
}

public class Demo2 {
    public static void main(String[] args) {
        //实现Runnable
        //1. 创建一个任务对象
        MyRunnable r = new MyRunnable();
        //2. 创建一个线程，并为其分配任务
        Thread t = new Thread(r);
        //3.  执行这个线程
        t.start();
        for (int i=0;i<10;i++){
            System.out.println("疑是地上霜"+i);
        }
    }
}

/**
 * 用于给线程进行执行的任务
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i=0;i<10;i++){
            System.out.println("床前明月光"+i);
        }
    }
}

5.带返回值的线程Callable

Runnable与Callable的相同点：都是接口；都可以编写多线程程序；都采用Thread.start()启动线程。

Runnable与Callable的不同点：Runnable没有返回值；Callable可以返回执行结果。

​ Callable接口的call()允许抛出异常；Runnable的run()不能抛出。

public class Demo9 {
    /**带有返回值的线程Callable
     * 1. 编写类实现Callable接口 , 实现call方法
     * class XXX implements Callable<T> {
     *      @Override
     *      public <T> call() throws Exception {
     *      return T;
     *      }
     *}
     *2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
     * FutureTask<Integer> future = new FutureTask<>(callable);
     * 3. 通过Thread,启动线程 new Thread(future).start();
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(c);
        new Thread(task).start();
        Integer j = task.get();
        System.out.println("返回值为:"+j);
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
    static class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            //Thread.sleep(3000);
            for (int i=0;i<10;i++){
                Thread.sleep(100);
                System.out.println(i);
            }
            return 100;
        }
    }
}

6.线程的使用

6.1.设置和获取线程名称

public class Demo3 {
    public static void main(String[] args) {
        //如何获取线程的名称
        System.out.println(Thread.currentThread().getName());
        new Thread(new MyRunnable(),"hahahaha").start();
        Thread t = new Thread(new MyRunnable());
        t.setName("youhohoho");
        t.start();
        new Thread(new MyRunnable()).start();
        new Thread(new MyRunnable()).start();
    }
    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());//currentThread()当前线程
        }
    }
}

6.2.线程休眠sleep

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        //线程的休眠 sleep
        for (int i=0;i<10;i++) {
            System.out.println(i);
            Thread.sleep(1000);
        }
    }
}

6.3.线程的中断

public class Demo5 {
    public static void main(String[] args) {
        //线程的中断
        //一个线程是一个独立的路径，它是否应该结束，由其自身决定
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for (int i=1;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //给线程t1添加中断标记
        t1.interrupt();
    }
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i=1;i<10;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("发现中断标记，线程自杀");
                    return;
                }
            }
        }
    }
}

7.守护线程

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

• 守护线程：用于守护用户线程，当最后一个用户线程结束，所有守护线程自动死亡
• 用户线程：当一个进程不包含任何的用户线程时，进行结束;直接创建的线程都是用户线程

public class Demo6 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        //设置t1为守护线程，必须写在启动前
        t1.setDaemon(true);
        t1.start();
        for (int i=1;i<=5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i=1;i<=10;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    return;
                }
            }
        }
    }
}

8.线程安全

8.1.同步代码块

package safe.demo7;
public class Demo1 {
    /**
     * 线程同步：synchronized
     * 线程不安全，解决方案1：同步代码块
     * 格式：synchronized(锁对象(任何对象){}
     */
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        //private Object o = new Object();//同一把锁才能排队
        @Override
        public void run() {
            Object o = new Object();//每个人都有一把锁，依然会出问题
            while (true){
                synchronized (o){
                    if (count>0){
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                    }else break;
                }
            }
        }
    }
}

8.2.同步方法

package safe.demo7;
public class Demo2 {
    /**
     * 线程同步：synchronized
     * 线程不安全，解决方案2：同步方法
     * 格式：synchronized(锁对象(任何对象){}
     */
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        @Override
        public void run() {
            while (true){
                boolean flag = sale();
                if (!flag)
                    break;
            }
        }
        public synchronized boolean sale(){
            //不是静态，锁是this
            //静态，锁是Ticket.class
            if (count>0){
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                return true;
            }
            return false;
        }
    }
}

8.3.显示锁Lock

package safe.demo7;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo3 {
    /**
     * 这三种方式都是非公平锁
     * 同步代码块和同步方法属于隐式锁，只需要写格式，不需要知道怎么锁的
     * 线程同步：lock
     * 线程不安全，解决方案3：显示锁 lock 子类 ReentrantLock
     * 更加体现出面向对象的机制
     */
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;
        //显示锁 l:fair参数为true，就是公平锁：谁先来谁先得
        private Lock l = new ReentrantLock( true);
        @Override
        public void run() {
            while (true){
                l.lock();
                    if (count>0){
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                    }else break;
                    l.unlock();
            }
        }
    }
}

8.4线程死锁

死锁概述

线程死锁是指两个或两个以上的线程互相持有对方所需要的资源，由于synchronized的特性，一个线程持有一个资源，或者说获得一个锁，在该线程释放这个锁之前，其它线程是获取不到这个锁的，而且会一直死等下去，因此这便造成了死锁。

死锁产生的条件

• 互斥条件：一个资源，或者说一个锁只能被一个线程所占用，当一个线程首先获取到这个锁之后，在该线程释放这个锁之前，其它线程均是无法获取到这个锁的。
• 占有且等待：一个线程已经获取到一个锁，再获取另一个锁的过程中，即使获取不到也不会释放已经获得的锁。
• 不可剥夺条件：任何一个线程都无法强制获取别的线程已经占有的锁
• 循环等待条件：线程A拿着线程B的锁，线程B拿着线程A的锁。

package safe.demo7;
public class Demo4 {
    //线程死锁
    public static void main(String[] args) {
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }
    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        public MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }
        @Override
        public void run() {
            p.say(c);
        }
    }
    //罪犯
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯:你放了我，我放人质");
            p.fun();
        }
        public synchronized void fun(){
            System.out.println("罪犯被放走了，罪犯也放了人质");
        }
    }
    //警察
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察:你放了人质，我放过你");
            c.fun();
        }
        public synchronized void fun(){
            System.out.println("警察救了人质，但罪犯跑了");
        }
    }
}

9.多线程通信问题

public class Demo8 {
    /**
     *多线程通信问题，生产者和消费者问题
     */
    public static void main(String[] args) {
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }
    //厨师
    static class Cook extends Thread{
        private Food f;
        public Cook(Food f){
            this.f = f;
        }
        @Override
        public void run() {
            for (int i=0;i<100;i++){
                if (i%2 == 0){
                    f.setNameAndTaste("老干妈小米粥","麻辣味");
                }else {
                    f.setNameAndTaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务员
    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f){
            this.f = f;
        }
        @Override
        public void run() {
            for (int i=0;i<100;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;
        //true 表示可以生产
        private boolean flag = true;
        public synchronized void setNameAndTaste(String name,String taste){
            if (flag){
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            if (!flag){
                System.out.println("服务员端走的菜的名称是:"+name+",味道:"+taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.线程池

10.1.缓存线程池

package demo10.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo1 {
    //线程池
    /*** 缓存线程池. (长度无限制)
     * 执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在,则创建线程 并放入线程池, 然后使用
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        //向线程池中 加入 新的任务
        service.execute(new Runnable() {
            @Override public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

10.2.定长线程池

package demo10.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo2 {
    /** 定长线程池. (长度是指定的数值)
     *  执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
    }
}

10.3.单线程线程池

package demo10.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo3 {
    public static void main(String[] args) {
        /**单线程线程池.  执行流程:
         *  1. 判断线程池 的那个线程 是否空闲
         *  2. 空闲则使用
         *  3. 不空闲,则等待 池中的单个线程空闲后 使用
         */
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称"+Thread.currentThread().getName());
            }
        });
    }
}

10.4.周期定长线程池

package demo10.threadpool;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Demo4 {
    /** 周期任务 定长线程池.
     *  执行流程:
     *  1. 判断线程池是否存在空闲线程
     *  2. 存在则使用
     *  3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     *  4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     *  周期性任务执行时:
     *  定时执行, 当某个时机触发时, 自动执行某任务 .
     */
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /** 定时执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字
         * 参数3. 时长数字的单位

        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("锄禾日当午");
            }
        },5, TimeUnit.SECONDS);*/
        /** 周期执行 *
         * 参数1. runnable类型的任务
         * 参数2. 时长数字(延迟执行的时长)
         * 参数3. 周期时长(每次执行的间隔时间)
         * 参数4. 时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("汗滴禾下土");
            }
        },3,2,TimeUnit.SECONDS);
    }
}

11.Lambda表达式

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

语法

lambda 表达式的语法格式如下：

(parameters) -> expression 或 (parameters) ->{ statements; }

以下是lambda表达式的重要特征:

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

示例：

package lambda.demo11;
public class Demo11 {
    /**
     *Lambda表达式
     * 函数式编程思想
     * 面向对象：创建对象调用方法 解决问题*/
    public static void main(String[] args) {
        //冗余的Runnable代码
        /*Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("youhohoho1");
            }
        });
        t.start();*/
        Thread t = new Thread(() -> {
            System.out.println("youhohoho2");
        });
        t.start();
    }
}

package lambda.demo11;
public class Demo1 {
    public static void main(String[] args) {
        //匿名内部类
        /*print(new MyMath() {
            @Override
            public int sum(int x, int y) {
                return x+y;
            }
        },100,200);*/
        print((int x, int y) -> {
                return x+y;
            },100,200);
    }
    public static void print(MyMath m,int x,int y){
        int num = m.sum(x,y);
        System.out.println(num);
    }
    //使用lanbda表达式时，一个接口里只能有一个方法
    static interface MyMath{
        int sum(int x,int y);
    }
}
      public void run() {
                System.out.println("youhohoho1");
            }
        });
        t.start();*/
        Thread t = new Thread(() -> {
            System.out.println("youhohoho2");
        });
        t.start();
    }
}