JavaSE基础——Java多线程（2）

1、静态代理

代理（proxy）是一种设计模式，提供了对目标对象的另一种访问方式，即通过代理对象访问目标对象。
利用代理可以在运行时创建一个实现了一组给定接口的新类。这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用。

静态代理在使用时，需要定义接口或者父类，被代理的对象和代理对象一起实现相同的接口或继承相同的父类，通俗的说就是你要和某个明星进行业务合作时，就要先找他的助理，通过它的助理再去和明星进行合作。

代码演示：

/**
 * 代理类和被代理类要实现的接口
 */
public interface Film {
    public abstract void filming();
}

/**
 * 被代理类
 */
public class Star implements Film {
    @Override
    public void filming() {
        System.out.println("star...filming");
    }
}

/**
 * 代理类
 */
public class Assistant implements Film{
    private Film film = null;

    public Assistant(Film film) {
        this.film = film;
    }

    @Override
    public void filming() {
        before();
        this.film.filming();
        after();
    }

    private void before() {
        System.out.println("找明星助理");
    }

    private void after() {
        System.out.println("付片酬");
    }
}

/**
 * 测试类
 */
public class ProxyTest {
    public static void main(String[] args) {
        Star star = new Star();
        Assistant assistant = new Assistant(star);
        assistant.filming();
    }
}

执行结果：
在这里插入图片描述
2、lambda表达式

带参数变量的表达式就被称为lambda表达式。

lambda表达式的语法：

1、我们用一串代码来检查两个字符串的长度大小
2、格式：参数可以为空 

  (参数) -> {表达式};

代码演示：

import java.util.Comparator;

public class LamdaDemo {
    public static void main(String[] args) {
        Comparator<String> stringComparator = (String first, String second) -> {
            if (first.length() > second.length()) {
                return 1;
            } else if (first.length() < second.length()) {
                return -1;
            } else {
                return 0;
            }
        };
        int compare = stringComparator.compare("zhangsan", "lisi");
        System.out.println(compare);
        Runnable runnable = () -> {
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            System.out.println(sum);
        };
        runnable.run();
    }
}

执行结果：
在这里插入图片描述
2、线程安全的集合CopyOnWriteArrayList

CopyOnWrite容器：

CopyOnWrite是一个写时复制的容器，通俗来说就是如果你给容器里面添加新的数据，添加的时候它就会复制一个新的容器，将你要添加的数据放进复制的这个容器中，添加完成以后，再将原容器的引用指向复制的这个新容器。这么做的好处就是我们可以多线程并发访问这个容器，因为你要添加这个的这个数据根本就不会添加到原容器，而是添加到了复制后的新容器中。

CopyOnWriteArrayList集合

代码演示：

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnArrayListDemo {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(100);
            System.out.println(list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ZHBlog_

发布了58 篇原创文章 · 获赞 7 · 访问量 2288

私信关注

JavaSE基础——Java多线程（2）

猜你喜欢