Java多线程 （一）- 创建线程、并发、静态代理、Lamda表达式

Java多线程 - 创建线程、并发、静态代理、Lamda表达式

继承Thread类

package com.archforce.aclub.forum.controller.activity;
public class TestThread extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("看代码"+i);
        }
    }
    public static  void main(String[] args){
        //main线程，主线程
        //创建一个线程对象
        TestThread testThread1 = new TestThread();
        testThread1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("主程序"+i);
        }
    }
}
​

• run()方法调用之后会先执行

• start() 方法调用，主线程和子线程会交替执行（只用start）

• 注意：线程开启不一定会立即执行，由CPU调度执行

• 线程不是按照代码顺序执行，是多个线程同时执行

实现Runnable方法

package com.archforce.aclub.forum.controller.activity;
​
//实现Runnable接口
public class TestRunable implements Runnable{
    @Override
    public void run(){
        for (int i = 0; i < 200; i++) {
            System.out.println("看代码"+i);
        }
    }
​
    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestRunable testRunable1 = new TestRunable();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testRunable1);
        thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("学习多线程"+i);
        }
    }
}

并发买票

package com.archforce.aclub.forum.controller.activity;
//多个线程同时操作同一个对象
//买火车票的例子
​
//发现问题，多个线程操作同一个线程的情况下，线程不安全，数据紊乱
public class BuyTickets implements Runnable{
    //票数
    private int tickets = 10;
    @Override
    public void run(){
        while (true){
            if(tickets<=0){
                break;
            }
​
            //CPU太快，模拟延时
            try{
                Thread.sleep(200);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"---拿到了第"+ tickets-- +"张票");
        }
    }
​
    public static void main(String[] args) {
        BuyTickets ticket = new BuyTickets();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"花花").start();
        new Thread(ticket,"老黑").start();
    }
}
​
//龟兔赛跑也是通过此方式实现

实现Callable接口

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

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

• 创建目标对象

• 创建执行服务：ExecutorService service=Excutors.newFixedThreadPool(1);

• 提交执行：Future result1 = service.submit(1);

• 获取结果：boolen r1 = result1.get()

• 关闭服务：service.shutdownNow();

  

   

静态代理模式

package com.archforce.aclub.forum.controller.activity;
//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//代理对象可以做许多真实对象做不了的事情
//真实对象专注于做自己的事
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();//你要结婚
        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();
    }
    public void before(){
        System.out.println("结婚之前，布置现场");
    }
    public void after(){
        System.out.println("结婚之后，收尾款");
    }
}

Lamda表达式

定义

• 避免匿名内部类定义过多

• 实质属于函数式编程

• (params) -> expression[表达式]

• (params) -> statement[语句]

• (params) -> {statements}

• new Thread (()->System.out.println("多线程学习.......")).start();

函数式接口

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

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

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

举例--1~6一步步简化

/**
 * 推导lamda表达式
 */
public class TestLamda1 {
    //3、静态内部类
    static class Like2 implements ILike{
        @Override
        public  void lamda(){
            System.out.println("i like lamda222!");
        }
    }
​
    public static void main(String[] args) {
        ILike like = new Like();
        like.lamda();
        like = new Like2();
        like.lamda();
​
        //4、局部内部类
        class Like3 implements ILike{
            @Override
            public void lamda(){
                System.out.println("i like lamda333!");
            }
        }
        like = new Like3();
        like.lamda();
​
        //5、匿名内部类，没有类的名称，必须借助接口或者父类
        like = new ILike(){
            @Override
            public void lamda(){
                System.out.println("i like lamda444!");
            }
        };
        like.lamda();
​
        //6、用lamda简化
        like = ()->{
            System.out.println("i like lamda555!");
        };
        like.lamda();
    }
}
​
​
//1、定义一个函数式接口（接口），一个接口只有一个抽象方法
interface ILike{
    void lamda();
}
//2、实现类
class Like implements ILike{
    @Override
    public void lamda(){
        System.out.println("i like lamda111!");
    }
}
​
/**
 * 打印
 * i like lamda111!
 * i like lamda222!
 * i like lamda333!
 * i like lamda444!
 * i like lamda555!
 */