多线程详解_1

p1-p10的内容

1： 多线程，进程，多任务

 

 

 

 

 

 

 2：创建线程的三种方式

 

 

 

2.1：继承Thread类

 

 

package Thread;

/**
 * author liulei
 * data   5.23
 * since 1.8
 * version 1.0
 * Description  继承Thread实现线程
 */
public class testThread {
    public static void main(String[] args) {
        T t = new T();
        t.start();//start方法启动线程
    }
}
class T extends Thread{//1 继承Thread
    public void run(){//2 重写run方法
        System.out.println("----hahah----");
    }

}

 

2.2：实现Runnable接口

 程序用到的Jar包文件https://files.cnblogs.com/files/henuliulei/commons-io-1.4.zip

多线程下载文件

package Thread;

import org.apache.commons.io.FileUtils;

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

/**
 * author liulei
 * data  5.23
 * since 1.8
 * version 1.0
 * Description  实现Runnable接口
 */
public class Test2 implements Runnable{


    @Override
    public void run() {
        WebDownloader down = new WebDownloader();
        try {
            down.downloader("https://csdnimg.cn/medal/github@240.png","a.png");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Test2 test2 =new Test2();
        new Thread(test2).start();
    }
}
class WebDownloader
{
    public  void downloader(String url,String name) throws IOException {
        FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}

多线程买票演示

package Thread;

/**
 * author liulei
 * data   5.23
 * since 1.8
 * version 1.0
 * Description  买票演示
 */
public class Test3 implements Runnable{
   private int ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if(ticketNums <= 0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--->拿到了"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
        Test3 test3 = new Test3();
        new Thread(test3,"线程一").start();
        new Thread(test3,"线程二").start();
        new Thread(test3,"线程三").start();
    }
}

多线程演示龟兔赛跑

package Thread;

/**
 * author liulei
 * data
 * since 1.8
 * version 1.0
 * Description  龟兔赛跑
 */
public class Game implements Runnable{
    private String winner = "";
    private Boolean gameover(int steps){
        if(winner != ""){
            return true;
        }
        if(steps >= 100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is " + winner);
            return true;
        }
        return  false;
    }
    @Override
    public void run() {
       for(int i = 0;i <= 100; i++){
           boolean flag = gameover(i);
           if(flag){
               break;
           }
           if(Thread.currentThread().getName().equals("兔子")){
               try {
                   Thread.sleep(1);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
           System.out.println(Thread.currentThread().getName() + "跑了"+ i + "步");
       }
    }

    public static void main(String[] args) {
        Game a = new Game();
        new Thread(a,"兔子").start();
        new Thread(a,"乌龟").start();
    }
}

 

 

 

2.3：实现Callable接口

 

 

 

 

 

package Thread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * author liulei
 * data  5.23
 * since 1.8
 * version 1.0
 * Description  实现Callable 接口
 */
public class Test4 implements Callable<Boolean> {
  String url;//图片路径
  String name;//文件名

    public Test4(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        WebDownloader down = new WebDownloader();
        down.downloader(url,name);
        System.out.println("下载成功");
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Test4 t = new Test4("https://csdnimg.cn/medal/github@240.png","aa.png");
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> submit = ser.submit(t);
        //获取结果
        Boolean aBoolean = submit.get();
        System.out.println(aBoolean);
        //关闭服务
        ser.shutdown();
    }
}

3：静态代理

 

 

 

package Thread;

/**
 * author liulei
 * data  5.23
 * since 1.8
 * version 1.0
 * Description  静态代理
 */
public class Test5 {
    /*
    真实对象和代理对象是实线同一个接口
    代理对象要代理真实角色
    好处：代理角色可以做很多真实角色做不了的事情
    真实对象专注做自己的事情
     */
    public static void main(String[] args) {
        weddingCompany webcop = new weddingCompany(new you());
        new Thread(()-> System.out.println("iloveyou")).start();
        webcop.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();
    }
    public void before(){
        System.out.println("结婚前，婚礼公司帮助我布置婚礼");

    }
    public void after(){
        System.out.println("结婚后，收费用");
    }
}

 

4：lambda表达式

 

 

 

 

 

 

 

package Thread;

/**
 * author liulei
 * data
 * since 1.8
 * version 1.0
 * Description  lambda表达式
 */
public class Test7 {
    /*
    lambda表达式只能有一行代码的情况下才能简化为一行去掉大括号，否则只能用代码块包裹
    前提是接口为函数式接口
    多个参数也可以去掉参数类型，要去掉都去掉，必须加括号
     */
    public class Like1 implements ILike{

        @Override
        public void lab() {
            System.out.println("成员内部类");
        }
    }
    public static void main(String[] args) {

        class Like2 implements ILike{

            @Override
            public void lab() {
                System.out.println("局部内部类");
            }
        }
        ILike Like3 = null;
        Like3 = ()-> System.out.println("lambda表达式");
        Like3.lab();//当然有参数也可以加入参数
    }
}
//定义一个函数式接口
interface ILike{
    void lab();
}
//实现类
class Like implements ILike{

    @Override
    public void lab() {
        System.out.println("实现类");
    }

}