多线程的创建，并发，静态代理，Lambda表达式

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

在操作系统中运行的程序就是进程（Process），如：QQ,播放器，游戏等等。

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

一个进程可以有多个线程(Thread），如视频中同时听到声音，看图像，看弹幕等等。线程是CPU调度和执行的单位

注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。

如果是模拟出来的多线程，即在一个cpu的情况下，在同一时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

线程是独立的执行路径。

在程序运行时，即使自己没有创建线程，后台也会有多个线程，如主线程，gc线程。gc:垃圾回收机制。守护线程。

main()为主线程，是系统的入口。

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

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

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

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

线程不一定立即执行，由cpu调度安排。

1.方式一 ：继承Thread类

　　步骤：自定义线程类继承Thread类

　　　　　重写run()方法，编写线程执行体

　　　　　创建线程对象，调用start()方法启动线程。

public class ThreadDemo extends Thread{ //1继承Thread类
    public static void main(String[] args) {
        ThreadDemo threadDemoo = new ThreadDemo(); //3.创建线程对象
        threadDemoo.start(); //调用start方法，开启该线程
        //主线程
        for (int i = 0;i<2000;i++){
            System.out.println("我在看弹幕"+i);
        }
    }

    @Override
    public void run() {
        //2.重写run方法。线程体
        for (int i = 0;i<2000;i++){
            System.out.println("我在听音乐。"+i);
        }

    }
}

练习：

实现多线程同步下载图片。

引入一个工具类：implementation "commons-io:commons-io:2.7"

为了使用里面的copyURLToFile(new URL(url),new File(name));  ------>将一个网络地址的内容变成文件。

步骤：

　　（1）创建一个下载器类 WebDownLoader

　　（2）创建一个多线程类，继承Thread。

代码如下：

package com.java.multithreading;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习thread，实现多线程同步下载图片
public class TestThread  extends Thread{
    private String url;
    private String name;

    //构造器
    public TestThread(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) {
        TestThread testThread01 = new TestThread("https://img2.baidu.com/it/u=450745774,808114680&fm=253&fmt=auto&app=138&f=JPEG?w=370&h=500","xixi01.jpg");
        TestThread testThread02 = new TestThread("https://img0.baidu.com/it/u=1145082949,2832027117&fm=253&fmt=auto&app=120&f=JPEG?w=500&h=914","xix02.jpg");
        TestThread testThread03 = new TestThread("http://t14.baidu.com/it/u=2571612918,2603191067&fm=224&app=112&f=JPEG?w=500&h=333","xixi03.jpg");

        testThread01.start();
        testThread02.start();
        testThread03.start();
    }

}

//下载器
class WebDownLoader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));  //将一个网络地址变成文件
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

运行结果如下：

线程是同步执行的，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。

Thread类是实现了Runnable接口的，我们继承Thread类，其实也就是实现了Runnable接口，然后重写了run方法。

通过new ThreadDemo().start();开启多线程， 它执行了Thread的无参构造方法

　　　　

2.方式二：实现Runnable接口

　　步骤：自定义线程类实现Runnable接口

　　　　　实现run()方法，编写线程执行体

　　　　　创建线程对象，调用start()方法启动线程。

package com.java.multithreading;

public class RunnableDemo implements Runnable{
    @Override
    public void run() {
        //线程体
        for (int i = 0;i<200;i++){
            System.out.println("我在听音乐。"+i);
        }

    }

    public static void main(String[] args) {
        RunnableDemo runnableDemo = new RunnableDemo(); //创建Runnable接口的实现类对象
        Thread thread = new Thread(runnableDemo); //创建线程对象，通过线程对象来开启我们的线程
        thread.start(); //开启线程

        //可以将上面代码简写为：
        new Thread(runnableDemo).start();

       ; //调用start方法，开启该线程
        //主线程
        for (int i = 0;i<1000;i++){
            System.out.println("我在看弹幕"+i);
        }
    }
}

练习：

实现多线程同步下载图片。

此处只需将方式一的代码修改两步：

　　将继承Thread类改为实现Runnable接口。

　　将new ThreadDemo().start改为RunnableDemo runnableDemo = new RunnableDemo();  new Thread(runnableDemo).start();

引入一个工具类：implementation "commons-io:commons-io:2.7"

为了使用里面的copyURLToFile(new URL(url),new File(name));  ------>将一个网络地址的内容变成文件。

步骤：

　　（1）创建一个下载器类 WebDownLoader。这里直接用方式一的下载器。

　　（2）创建一个多线程类，实现Runnable接口。

代码如下：

package com.java.multithreading;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestRunnable implements Runnable{
    private String url;
    private String name;

    //构造器
    public TestRunnable(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) {
    TestRunnable testRunnable01 = new TestRunnable("https://img2.baidu.com/it/u=450745774,808114680&fm=253&fmt=auto&app=138&f=JPEG?w=370&h=500","xixi01.jpg");
    TestRunnable testRunnable02 = new TestRunnable("https://img0.baidu.com/it/u=1145082949,2832027117&fm=253&fmt=auto&app=120&f=JPEG?w=500&h=914","xix02.jpg");
    TestRunnable testRunnable03 = new TestRunnable("http://t14.baidu.com/it/u=2571612918,2603191067&fm=224&app=112&f=JPEG?w=500&h=333","xixi03.jpg");

   // testThread01.start();
   // testThread02.start();
   // testThread03.start();
    new Thread(testRunnable01).start();
    new Thread(testRunnable02).start();
    new Thread(testRunnable03).start();
}

}

结果如下：

两者比较：

继承Thread类：

• 子类继承Thread类具备多线程能力
• 启动线程：子类对象.start()
• 不建议使用：避免oop(面向对象编程)单继承局限性

实现Runnable接口：

• 实现接口Runnable具有多线程能力
• 启动线程：new Thread(Runnable接口的实现类对象).start()
• 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。

3.方式三：实现Callable接口

　　步骤：

　　　　实现Callable接口，需要返回值类型

　　　　重写call方法，需要抛出异常

　　　　创建目标对象 t1

　　　　创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);

　　　　提交执行：Future<Boolean> result = ser.submit(t1);

　　　　获取结果：boolean r1 = result.get();

　　　　关闭服务：ser.shutdownNow();

package com.java.multithreading;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableDemo implements Callable<Boolean>{
    private String url;
    private String name;

    public CallableDemo(String url,String name){
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() throws Exception {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downloader(url,name);
        System.out.println("下载了文件："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableDemo callableDemo1 = new CallableDemo("https://img2.baidu.com/it/u=450745774,808114680&fm=253&fmt=auto&app=138&f=JPEG?w=370&h=500","xixi01.jpg");
        CallableDemo callableDemo2 = new CallableDemo("https://img0.baidu.com/it/u=1145082949,2832027117&fm=253&fmt=auto&app=120&f=JPEG?w=500&h=914","xixi02.jpg");
        CallableDemo callableDemo3 = new CallableDemo("http://t14.baidu.com/it/u=2571612918,2603191067&fm=224&app=112&f=JPEG?w=500&h=333","xixi03.jpg");
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(1);
        //提交线程
        Future<Boolean> result1 = ser.submit(callableDemo1);
        Future<Boolean> result2 = ser.submit(callableDemo2);
        Future<Boolean> result3 = ser.submit(callableDemo3);
        //获取结果
        boolean r1 = result1.get();//此处的异常直接抛出
        boolean r2 = result2.get();
        boolean r3 = result3.get();
        //关闭服务
        ser.shutdownNow();
    }
}

运行结果：

4.初始并发问题

多个线程同时操作同一个对象，如购买过车票。

package com.java.multithreading;

public class
    //初识并发问题 。多个线程同时操作同一个对象，如购买过车票。线程紊乱，不安全。
ConcurrencyDemo implements Runnable{
    private int ticketNums = 5; //总票数
    @Override
    public void run() {
        while (true){
            if (ticketNums <= 0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"---->拿到了第"+ticketNums--+"票");

        }
    }

    public static void main(String[] args) {
        ConcurrencyDemo concurrencyDemo = new ConcurrencyDemo();
        //多条线程操作同一个实现类。即三条线程一起去抢总数为10的火车票。
        new Thread(concurrencyDemo,"一号").start();
        new Thread(concurrencyDemo,"二号").start();
        new Thread(concurrencyDemo,"三号").start();
    }

}

运行结果如下：

会出现一号将票全部拿完的情况。

现在我们模拟延时看看：

package com.java.multithreading;

public class
    //初识并发问题 。多个线程同时操作同一个对象，如购买过车票。线程紊乱，不安全。
ConcurrencyDemo implements Runnable{
    private int ticketNums = 5; //总票数
    @Override
    public void run() {
        while (true){
            if (ticketNums <= 0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"---->拿到了第"+ticketNums--+"票");

        }
    }

    public static void main(String[] args) {
        ConcurrencyDemo concurrencyDemo = new ConcurrencyDemo();
        //多条线程操作同一个实现类。即三条线程一起去抢总数为10的火车票。
        new Thread(concurrencyDemo,"一号").start();
        new Thread(concurrencyDemo,"二号").start();
        new Thread(concurrencyDemo,"三号").start();
    }

}

运行结果如下：

出现了紊乱。此刻的线程就是不安全的。

5.静态代理模式

package com.java.multithreading;

//静态代理模式对比Thread
/*
  举例:结婚
  结婚需要实现结婚的接口。
  结婚不必新娘新郎亲自布置现场，可让婚庆公司帮忙
  结婚时只需新人到场举行婚礼即可。
  注意：真实对象和代理对象都要实现同一个接口
 */

public class StaticProxy {
    public static void main(String[] args) {
        Groom groom = new Groom();
        //WeddingCompany实现了Marry接口，Thread实现Runnable接口；
        new WeddingCompany(groom).Wedding();
        new Thread(() -> System.out.println("like")).start();
        //Thread类是一个代理，代理中间的真实对象，然后调用start方法
    }
}

//结婚的接口
interface Marry{
    void Wedding();//婚礼
}

//真实角色，实现结婚接口，目的是参加婚礼
class Groom implements Marry{
    @Override
    public void Wedding() {
        System.out.println("新郎参加婚礼");
    }
}

//代理角色，实现结婚接口，目的是筹备婚礼
class WeddingCompany implements Marry{
    private Marry target;

    public WeddingCompany(Marry target){
        this.target = target;
    }
    @Override
    public void Wedding() {
        System.out.println("婚庆公司筹备婚礼");
        this.target.Wedding();//然后真实对象来参加婚礼
    }
}

6.Lambda表达式

避免匿名内部类过多，其实质属于函数式编程的概念。

函数式接口的定义：

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

　　如Runnable接口：

package java.lang;

@FunctionalInterface
public interface Runnable {
    void run();
}

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

推导 lambda表达式：

原始代码：

package com.java.multithreading;
//推导Lamda表达式
public class LambdaDemo {
    public static void main(String[] args) {
        IStudy iStudy = new IStudy();
        iStudy.lambda();
    }
}

//定义一个函数式接口
interface Study{
    void lambda();//在接口里的方法，就是抽象方法
}

//实现类
class IStudy implements Study{
    @Override
    public void lambda() {
        System.out.println("我在学习");
    }
}

静态内部类

package com.java.multithreading;
//推导Lamda表达式
public class LambdaDemo {
    //实现类
   static  class IStudy implements Study{
        @Override
        public void lambda() {
            System.out.println("我在学习");
        }
    }
    public static void main(String[] args) {
        IStudy iStudy = new IStudy();
        iStudy.lambda();
    }
}

//定义一个函数式接口
interface Study{
    void lambda();//在接口里的方法，就是抽象方法
}

局部内部类

package com.java.multithreading;
//推导Lamda表达式
public class LambdaDemo {

    public static void main(String[] args) {
        //实现类
         class IStudy implements Study{
            @Override
            public void lambda() {
                System.out.println("我在学习");
            }
        }
        IStudy iStudy = new IStudy();
         iStudy.lambda();
    }
}

//定义一个函数式接口
interface Study{
    void lambda();//在接口里的方法，就是抽象方法
}

匿名内部类

package com.java.multithreading;
//推导Lamda表达式
public class LambdaDemo {

    public static void main(String[] args) {
        //实现类
        Study iStudy = new Study() {
            @Override
            public void lambda() {
                System.out.println("我在学习");
            }
        };
       iStudy.lambda();
    }
}

//定义一个函数式接口
interface Study{
    void lambda();//在接口里的方法，就是抽象方法
}

用lambda简化

package com.java.multithreading;
//推导Lamda表达式
public class LambdaDemo {

    public static void main(String[] args) {
        //实现类
        Study iStudy = ()->{
                System.out.println("我在学习");
        };
       iStudy.lambda();
    }
}

//定义一个函数式接口
interface Study{
    void lambda();//在接口里的方法，就是抽象方法
}

说明：非原创，跟着b站狂神敲的