java 多线程基础，

java 多线程基础，

静态代理设计模式

/**
 * 静态代理设计模式
 * 1、真实角色
 * 2、代理角色
 * 3、二者实现相同的接口
 * @author L J
 */
public class StaticProxy {
    public static void main(String[] args) {
        //创建真实角色
        Marry you = new You();
        //创建代理角色+真实角色的引用
        Marry wedd = new WeddingCompany(you);
        //执行任务
        wedd.marry();
    }
}

//接口
interface Marry {
    void marry();
}

//真实角色
class You implements Marry {
    @Override
    public void marry() {
        System.out.println("你和诗诗结婚");
    }
}

//代理角色
class WeddingCompany implements Marry {
    private Marry you;
    public WeddingCompany() {
    }

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

    //结婚之前要做的事情
    public void before() {
        System.out.println("发喜帖，布置酒席");
    }

    //结婚之后要做的事情
    public void after() {
        System.out.println("送客");
    }

    @Override
    public void marry() {
        before();
        you.marry();
        after();
    }
}

实现多线程的三种方式

• 继承Thread类，重写run方法
• 实现Runnable接口，实现run方法
  优点：避免单继承；便于资源的共享（一个线程对象可以启动多个线程）

/**
 * 方便资源共享
 * @author L J
 */
public class Web12306 implements Runnable {
    private int num = 50;
    @Override
    public void run() {
        while(true) {
            if(num <= 0) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "抢到了" + num--);
        }
    }

    public static void main(String[] args) {
        //真实角色
        Web12306 web = new Web12306();
        //代理
        Thread t1 = new Thread(web, "路人甲");
        Thread t2 = new Thread(web, "路人乙");
        Thread t3 = new Thread(web, "路人丙");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

• 实现Callable接口，实现call方法
  优点：可以抛出异常；可以有返回值

/**
 * 使用Callable创建线程
 * 模拟龟兔赛跑
 * @author L J
 */
public class Call {
    public static void main(String[] args) throws Exception {
        //创建线程
        ExecutorService ser = Executors.newFixedThreadPool(2);
        Race tortoise = new Race("惠比寿", 1000);
        Race rabbit = new Race("山兔", 500);
        //获取值
        Future<Integer> result1 = ser.submit(tortoise);
        Future<Integer> result2 = ser.submit(rabbit);

        Thread.sleep(2000);  //2秒
        tortoise.setFlag(false); //停止线程体中的循环
        rabbit.setFlag(false);

        int num1 = result1.get();
        int num2 = result2.get();

        System.out.println(tortoise.getName()+ "跑了" + num1 + "步");
        System.out.println(rabbit.getName()+ "跑了" + num2 + "步");
        //停止服务
        ser.shutdownNow();
    }
}

class Race implements Callable<Integer> {
    private String name; //名称
    private long time; 
    private boolean flag = true;
    private int step;    //步数
    public Race() {
    }

    public Race(String name, long time) {
        this.name = name;
        this.time = time;
    }

    @Override
    //可以有返回值，可以抛出异常
    public Integer call() throws Exception {
        while(flag) {
            Thread.sleep(time); //延时
            step++;
        }
        return step;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public long getTime() {
        return time;
    }
    public void setTime(long time) {
        this.time = time;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public int getStep() {
        return step;
    }
    public void setStep(int step) {
        this.step = step;
    }
}

线程状态转换图

单例设计模式

/**
 * 懒汉式
 * @author L J
 */
public class MyJvm {
    //声明私有的静态属性
    private static MyJvm instance;
    //构造器私有化
    private MyJvm() {
    }
    //对外提供访问属性的静态方法，确保该对象存在
    public static MyJvm getInstance() {
        if(instance == null) {
            instance = new MyJvm();
        }
        return instance;
    }
}

/**
 * 饿汉式
 * @author L J
 */
class Jvm {
    //声明私有的静态属性，同时创建该对象
    //静态内部类在使用的时候加载，延缓加载时机，提高效率
    private static class JvmHolder {
        private static Jvm instance = new Jvm();
    }
    //构造器私有化
    private Jvm() {

    }
    //对外提供访问属性的静态方法
    public static Jvm getInstance() {
        return JvmHolder.instance;
    }
}

/**
 * 双重校验锁 
 * @author L J
 */
class Singleton {
    private volatile static Singleton singleton;
    private Singleton(){}
    public static Singleton getSingleton(){
        if(singleton == null) {  //提高效率，已经创建对象就直接返回
            synchronized (Singleton.class) {
                if(singleton == null) { //确保安全
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

任务调度

/**
 * 任务调度
 * schedule(task, firstTime)
 * schedule(task, firstTime, period)
 * task 任务
 * firstTime 第一次开始执行任务的时间
 * period 周期，间隔多久执行一次任务
 * @author L J
 */
public class TimerDemo {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("good job");
            }
        }, 1000);
    }
}