Java多线程-1

Process和Thread

• 程序。程序是指令和数据的有序集合，其本身没有运行的含义，是一个静态的概念
• 进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
• 通常一个进程包含若干个线程 当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位
• 注意：很多多线程是模拟出来的，真正的多线程是指由多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉

核心概念

• 线程是独立的执行路径
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程
• mian()之所以称为主进程，为系统的入口，用于执行整个程序
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统密切相关的，先后顺序是不能人为的干预的
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
• 线程会带来额外的开销，如CPU调度开销、并发控制开销
• 每个线程都在自己的工作内存交互，内存控制不当会造成数据不一致

三种创建方式

一、Thread

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

package com.yang.lesson01;
//创建线程方式一：继承Thread类，重写run()方法，调用start()开启多线程
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run()方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main()线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()开启多线程
        testThread1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }

}

下载网络图片

package com.yang.lesson01;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
//多线程同步下载图片
public class TestThread2 extends Thread{
    private String url;//地址
    private String name;//保存文件名

    public TestThread2(String url,String name) {
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downLoader(url,name);
        System.out.println("下载完成"+name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://image.baidu.com/search/albumsdetail?tn=albumsdetail&word=渐变风格插画&fr=albumslist&album_tab=设计素材&album_id=409&rn=30","1,jpeg");
        TestThread2 t2 = new TestThread2("https://image.baidu.com/search/albumsdetail?tn=albumsdetail&word=渐变风格插画&fr=albumslist&album_tab=设计素材&album_id=409&rn=30","2,jpeg");
        TestThread2 t3 = new TestThread2("https://image.baidu.com/search/albumsdetail?tn=albumsdetail&word=渐变风格插画&fr=albumslist&album_tab=设计素材&album_id=409&rn=30","3,jpeg");

        t1.start();
        t2.start();
        t3.start();
    }

}
//下载器
class WebDownLoader{
    //下载方法
    public void downLoader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("下载图片出错");
        }
    }
}

二、实现Runnable

• 定义MyRunnable类，实现Runnable接口
• 实现run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程
• 推荐使用Runnable对象，因为Java单继承的局限性

package com.yang.lesson01;


//定义MyRunnable类，实现Runnable接口 实现run()方法，编写线程执行体  创建线程对象，调用start()方法启动线程
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run()方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口类的实现类对象
        TestThread3 testTread3 = new TestThread3();
        //创建线程对象,通过我们的线程对象来开启我们的线程代理
//        Thread thread = new Thread(testTread3);
//
//        thread.start();

        new Thread(testTread3).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

买票问题

package com.yang.lesson01;

//多个线程同时操作一个对象
//火车买票问题

//问题：多个线程同时操作一个资源的情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable{

    private int ticketNums = 10;

    @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) {
        TestThread4 testThread4 = new TestThread4();

        new Thread(testThread4,"小明").start();
        new Thread(testThread4,"老师").start();
        new Thread(testThread4,"黄牛").start();
    }
}

package com.yang.lesson01;


//模拟龟兔赛跑
public class Race implements Runnable{
    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
        //模拟兔子休息
        if (Thread.currentThread().getName().equals("兔子")&& i%10==0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

            boolean flag = gameOver(i);
            //如果比赛结束了，就停止程序
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }

    }
    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!=null){
            return true;//有一个胜利者另一个人就不跑了
        }
        if (steps>=100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is "+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race,"乌龟").start();
        new Thread(race,"兔子").start();
    }
}

三、Callable

1. 实现Callable方法，需要返回值类型
2. 重写call方法需要返回异常
3. 创建目标对象
4. 创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(1);
5. 提交执行 Future r1 = ser.submit(t1);
6. 获取结果 boolean rs1 = r1.get();
7. 关闭服务ser.shutdown();
   • 利用Callable改造下载图片案例

package com.yang.lesson01;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
/*Callable优点
1，可以定义返回值
2，可以抛出异常
*/
public class TestCallable implements Callable<Boolean> {
    private String url;//地址
    private String name;//保存文件名

    public TestCallable(String url,String name) {
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownLoader2 webDownLoader = new WebDownLoader2();
        webDownLoader.downLoader(url,name);
        System.out.println("下载完成"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://image.baidu.com/search/albumsdetail?tn=albumsdetail&word=渐变风格插画&fr=albumslist&album_tab=设计素材&album_id=409&rn=30","1,jpeg");
        TestCallable t2 = new TestCallable("https://image.baidu.com/search/albumsdetail?tn=albumsdetail&word=渐变风格插画&fr=albumslist&album_tab=设计素材&album_id=409&rn=30","2,jpeg");
        TestCallable t3 = new TestCallable("https://image.baidu.com/search/albumsdetail?tn=albumsdetail&word=渐变风格插画&fr=albumslist&album_tab=设计素材&album_id=409&rn=30","3,jpeg");

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);

        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        //关闭服务
        ser.shutdown();
    }

}
//下载器
class WebDownLoader2{
    //下载方法
    public void downLoader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("下载图片出错");
        }
    }
}

静态代理

import java.sql.SQLOutput;

/*
静态代理模式总结
1，真实对象和代理对象都要实现同一接口
2，代理对象要代理真实角色

优点：
1，代理对象可以做很多真实对象做不了的事情
2，真实对象专注做自己的事情
*/
public class StaticProxy {
    public static void main(String[] args) {

        You you = new You();

        new Thread(  ()-> System.out.println("我爱你")).start();
        
        new WeddingCompany(new You()).HappyMarry();
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarry();
    }

}
interface Marry{
    void HappyMarry();
}

//真实角色，你去结婚
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("我要结婚了，很开心");
    }
}
//代理角色--婚庆公司，帮助你结婚
class WeddingCompany implements Marry{
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//这是真实对象
        after();
    }

    private void after() {
        System.out.println("收尾款");
    }

    private void before() {
        System.out.println("布置现场");
    }
}

Lambda表达式

• λ希腊字母字母排名第十一位
• 避免匿名内部类定义过多
• 其实质属于函数式编程概念

new thread(()->System.out.println("我爱你")).start();

• Functional Interface（函数式接口）

• 函数式接口的定义：

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

    public interface Runnable{
      public abstract void run();
    }
    

  • 对于函数式接口，我们采用Lambda表达式来创建该接口的对象

package com.yang.lambda;
/*
推导lambda
 */
public class TestLambda1 {
    //3，静态内部类
    static class Like2 implements ILike{

        @Override
        public void lambda() {
            System.out.println("I love you too!");
        }
    }

    public static void main(String[] args) {
        Like like = new Like();
        like.lambda();

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

        //4,局部内部类
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("I love you yet!");
            }
        }

        Like3 like3 = new Like3();
        like3.lambda();
        //5，匿名内部类,没有类的名称，只能借助接口或者父类
        like = new Like(){

            @Override
            public void lambda() {
                System.out.println("I love you too too!");
            }
        };
        like.lambda();

        //6，lambda实现
        ILike like4 = () -> {
            System.out.println("I love you too yet!");
        };

        like4.lambda();

    }
}
//1，定义一个函数式接口
interface ILike{
    void lambda();
}
//2，实现类
class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("I love you!");
    }
}

简化

package com.yang.lambda;

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love = null;
//        //1,lambda表示简化
//        ILove love = (int a) -> {
//            System.out.println("I love you "+a);
//        };
//        //简化1，参数类型
//        love = (a) -> {
//            System.out.println("I love you "+a);
//        };
        //简化2，简化括号
//        love = a -> {
//            System.out.println("I love you "+a);
//        };
        //简化3，去掉花括号
        love = a -> System.out.println("I love you "+a);
        love.Love(2);
        //总结：
        //表达式只有一行可以简化成一行
        //两行用代码块
        //前提：必须是函数式接口
        //多个参数可以去掉参数类型，要去掉就都去掉
    }
}
interface ILove{
    void Love(int a);
}