Java学习笔记6

静态代理例子

package proxy;
interface Mary{
    void HappyMary();
}
//真实角色，当事人结婚
class You implements Mary{
    @Override
    public void HappyMary() {
        System.out.println("当事人结婚");
    }
}
//代理角色，帮助当事人结婚
class WeddingCompany implements Mary{
    private Mary target;

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

    @Override
    public void HappyMary() {
        before();
        target.HappyMary();
        after();
    }
    private void before()
    {
        System.out.println("结婚前布置现场");
    }
    private void after()
    {
        System.out.println("结婚后，收尾款");
    }
}
public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany company = new WeddingCompany(new You());
        company.HappyMary();

    }
}

静态代理模式总结

真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色
优点
代理对象可以做很多真实对象做不了的事情
真实对象专注于自己的事情

Lambda表达式

避免匿名内部类定义过多
使代码更加简洁
去掉没有意义的代码，只留下核心逻辑
其实质属于函数式编程的概念
(params)->expression[表达式]
(params)->statement[语句]
(params)->{statement}
例如

a->System.out.println("test"+a);
new Thread(()->System.out.println("test..."));

Functional interface(函数式接口)是学习Java8 lambda表达式的关键

函数式接口的定义

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

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

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

package lambda;

public class TestLambda {
    public static void main(String[] args) {
        ITest t1=a-> System.out.println("test："+a);
        t1.test(3);
    }
}
interface ITest{
    void test(int i);
}

###Lambda表达式小结
Lambda表达式在原先代码只有一行的情况下才能简化成一行，如果有多行，那么就用代码块包裹
前提是接口是函数接口
Lambda表达式中的参数可以去掉参数类型，但必须统一去掉

线程状态

• 线程对象一旦创建就进入新生状态
• 当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行
• 调度后，进入运行状态，线程才真正执行线程体的代码块
• 线程中断或结束，一旦进入死亡状态，就不能再次启动
• 当调度sleep,wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行

线程方法

setPriority(int newPriority) 更改线程优先级
static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
void join() 等待该线程终止
static void yield() 暂停当前正在执行的线程对象并执行其他线程
void interrupt() 中断线程，不建议使用
boolean isAlive() 测试线程是否处于活动状态

停止线程

不推荐使用JDK提供的stop(),destroy()方法【已废弃】
推荐线程自己停止下来
建议使用一个标志位作为线程的终止变量

package thread;

public class TestThread2 implements Runnable {
    //线程标识符
    private boolean flag=true;
    @Override
    public void run() {
        while (flag)
        {
            System.out.println("线程正常工作");
        }
    }
    //停止线程
    public void stop()
    {
        this.flag=false;
    }

    public static void main(String[] args) {
        TestThread2 thread2 = new TestThread2();
         new Thread(thread2).start();
        for (int i = 0; i < 2000; i++) {
            if(i==1500)
            {
                thread2.stop();
                System.out.println("线程结束");
            }
        }
    }
}

线程休眠

sleep(时间)指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时、倒计时等
每个对象都有一把锁，sleep不会释放锁

public class TicketThread implements Runnable {
    private int ticket=10;
    @Override
    public void run() {
        while (true)
        {
            if(ticket<=0)
            {
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买到了第"+ticket--+"张票");
        }
    }

    public static void main(String[] args) {
        TicketThread thread=new TicketThread();
        new Thread(thread,"用户1").start();
        new Thread(thread,"用户2").start();
        new Thread(thread,"用户3").start();
    }
}

倒计时

package thread;

public class TimeDown {
    public static void tenDown() throws InterruptedException {
        int i=10;
        while(true)
        {
            System.out.println(i--);
            Thread.sleep(1000);
            if(i<0){break;}
        }
    }

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功

package thread;

public class TestYield {
    public static void main(String[] args) {
        UserYield yield1= new UserYield();
        UserYield yield2= new UserYield();
        new Thread(yield1).start();
        new Thread(yield2).start();
    }

}
class UserYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

Join

Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

package thread;

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程插队");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin join = new TestJoin();
        Thread thread=new Thread(join);
        thread.start();
        for (int i = 0; i < 20; i++) {
            if(i==5)thread.join();
            System.out.println("main线程");
        }
    }
}