精华内容
下载资源
问答
  • Java-12-多线程(静态代理模式) 要求: 真实角色 代理角色 真实角色和代理角色要实现同一个接口 代理角色要持有真实角色的引用。 在Java中线程的设计就使用了静态代理设计模式, 其中自定义线程类实现Runable接口,...

    Java-12-多线程(静态代理模式)

    要求:

    真实角色

    代理角色

    真实角色和代理角色要实现同一个接口

    代理角色要持有真实角色的引用。

    在Java中线程的设计就使用了静态代理设计模式,

    其中自定义线程类实现Runable接口,Thread类也实现了Runalbe接口,

    在创建子线程的时候,传入了自定义线程类的引用,再通过调用start()方法,调

    用自定义线程对象的run()方法。实现了线程的并发执行。

    设置静态代理模式

    public class StaticProxy {
        public static void main(String[] args) {
            //创建真实角色
            RealRole realRole = new RealRole();
            //创建代理角色
            ProxyRole proxyRole = new ProxyRole(realRole);
            //代理角色工作,
            proxyRole.todo();
    
            //MyRunnable 和 Thread 都实现了Runnable接口
            //MyRunnable t = new MyRunnable();
            //Thread t1 = new Thread(t);
            //t1.start()
    
            //vs
            /*
            * new ProxyRole(new RealRole).todo();
            * new Thread(new Runnable).start();
            * */
        }
    }
    
    
    //共同的接口,都要实现todo方法
    interface Commons{
        void todo();
    }
    
    //真实角色
    class RealRole implements Commons{
        //重写todo方法
        @Override
        public void todo() {
            System.out.println("真实角色要做的事情");
        }
    }
    //代理角色
    class ProxyRole implements Commons{
        // 持有真实角色的引用
        private Commons realRole;
        //无参构造方法
        public ProxyRole(){
    
        }
        //以真实角色的引用为参数的构造方法
        public ProxyRole(Commons realRole){
            this.realRole = realRole;
        }
    
        //重写todo方法
        @Override
        public void todo() {
            //在真实角色做自己的事情之前,代理角色做准备工作
            dobefore();
            //真实角色自己要做的事情
            this.realRole.todo();
            //代理角色的收尾工作
            doafter();
    
    
        }
    
        private void dobefore() {
            System.out.println("准备工作");
        }
        private void doafter() {
            System.out.println("收尾工作");
        }
    }
    
    展开全文
  • 直接用代码实现一下: package duoxiancheng; public class StaticProxy { public static void main(String[] args) { //真实对象,you You you = new You(); WeddingCompany weddingCompany = new ...

    直接用代码实现一下:

    package duoxiancheng;
    
    public class StaticProxy {
        public static void main(String[] args) {
            //真实对象,you
            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;
    
        WeddingCompany(Marry target) {
            this.target = target;
        }
    
        @Override
        public void HappyMarry() {
            before();
    
            //目标对象结婚
            this.target.HappyMarry();
            after();
        }
    
        private void after() {
            System.out.println("结婚后收尾款");
        }
    
        private void before() {
            System.out.println("结婚前布置现场");
        }
    }
    
    
    

    在这里插入图片描述
    总结:
    真实对象和代理对象都要实现同一个接口
    代理对象要代理真实角色
    好处:
    代理对象可以帮助对象做一些事情,
    真实对象专注做自己的事情

    在多线程里面使用thread接口作为代理实现runnable方法
    好了,今天先到这里~

    展开全文
  • 代码都是线程安全的,使用synchronized来实现同步方法和同步块的声明: 第一种代码是 购票的客户,客户为主要操作人 package top.xq.thread; import java.util.ArrayList; import java.util...

    在这里贴出这个代码,有两个原因:

    1. 认识同一种需求场景,可以由不同的实现方式
    2. 认识使用设计模式以后,代码编写的逻辑是如何变化的

    代码都是线程安全的,使用synchronized来实现同步方法和同步块的声明:

    第一种代码是

    购票的客户,客户为主要操作人
    package top.xq.thread;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 类名称 CinemaAndCustomer
     * 说明 演示影院售票以及客户买票的过程;
     * 客户可以一次性买多张票;
     * 影院可以一次售卖多张票
     * 作者 IT小黑
     * 日期 2019/10/15 13:23
     */
    public class CinemaAndCustomer {
    
        public static void main(String[] args) {
    
            // 影院里的座位号码
            List<Integer> seats = new ArrayList<>();
            seats.add(1);
            seats.add(2);
            seats.add(3);
            seats.add(4);
            seats.add(5);
    
            CinemaLocal cinemaLocal = new CinemaLocal("万达影城", seats);
    
            // 定义客户进行购票
            List<Integer> customer1Seats = new ArrayList<>();
            customer1Seats.add(1);
            customer1Seats.add(4);
            HappyCustomer customer1 = new HappyCustomer(customer1Seats, cinemaLocal, "张三");
    
            // 定义客户进行购票
            List<Integer> customer2Seats = new ArrayList<>();
            customer2Seats.add(2);
            customer2Seats.add(5);
            customer2Seats.add(7);
            HappyCustomer customer2 = new HappyCustomer(customer2Seats, cinemaLocal, "李四");
    
            // 启动购买任务
            new Thread(customer1).start();
            new Thread(customer2).start();
        }
    
    }
    
    /**
     * 购票的客户,客户为主要操作人
     */
    class HappyCustomer implements Runnable{
    
        private CinemaLocal cinemaLocal;
        private List<Integer> buySeates;
        private String name;
    
        public HappyCustomer(List<Integer> buySeates, CinemaLocal cinemaLocal, String name) {
            this.buySeates = buySeates;
            this.cinemaLocal = cinemaLocal;
            this.name = name;
        }
    
        @Override
        public void run() {
    
            boolean isSuccess = cinemaLocal.saleTickets(buySeates);
            if(isSuccess) {
                System.out.println(name + "成功的购买了" + buySeates.size() + "张票!");
            }else {
                System.out.println("系统暂不支持" + name + "无法完成购买" + buySeates.size() + "张票的提交!");
            }
    
        }
    }
    /**
     * 定义本地影院的实体类
     */
    class CinemaLocal {
        /**
         * 座位集合以及名字
         */
        private List<Integer> seats;
        private String name;
    
        public CinemaLocal(String name, List<Integer> seats) {
            this.name = name;
            this.seats = seats;
        }
    
        /**
         * 卖票
         * @param buySeats 购买的数量
         * @return
         */
        boolean saleTickets(List<Integer> buySeats) {
    
            if(seats.size() <= 0) {
                return false;
            }
            synchronized (this) {
                // 集合之间的删除处理
                List<Integer> copySeats = copyList(seats);
    
                copySeats.removeAll(buySeats);
                if(copySeats.size() + buySeats.size() == seats.size()) {
                    // 重新刷新影院剩余的票
                    seats = copySeats;
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 复制List集合
         * @param originalList
         * @param <T>
         * @return
         */
        private <T> List<T> copyList(List<T> originalList) {
            List<T> copyList = new ArrayList<>();
            copyList.addAll(originalList);
            return copyList;
        }
    }
    

    第二种代码是使用了静态代理模式:

    购票的客户,客户为次要操作人,只要客户来了,由影院来发票,影院作为主要操作人
    package top.xq.thread;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 类名称 CinemaAndCustomer
     * 说明 演示影院售票以及客户买票的过程;
     * 客户可以一次性买多张票;
     * 影院可以一次售卖多张票
     * 使用静态代理的方式实现,synchronized声明方法来实现;因为synchronized声明在方法上,默认是this对象,而当前场景this需要是影院
     * 作者 IT小黑
     * 日期 2019/10/15 13:23
     */
    public class CinemaAndCustomer2 {
    
        public static void main(String[] args) {
    
            // 影院里的座位号码
            List<Integer> seats = new ArrayList<>();
            seats.add(1);
            seats.add(2);
            seats.add(3);
            seats.add(4);
            seats.add(5);
    
            CinemaLocal2 cinemaLocal = new CinemaLocal2("万达影城", seats);
    
            // 定义客户进行购票
            List<Integer> customer1Seats = new ArrayList<>();
            customer1Seats.add(1);
            customer1Seats.add(4);
            HappyCustomer2 customer1 = new HappyCustomer2(customer1Seats, cinemaLocal, "张三");
    
            // 定义客户进行购票
            List<Integer> customer2Seats = new ArrayList<>();
            customer2Seats.add(2);
            customer2Seats.add(5);
            customer2Seats.add(3);
            HappyCustomer2 customer2 = new HappyCustomer2(customer2Seats, cinemaLocal, "李四");
    
            // 启动购买任务
            customer1.start();
            customer2.start();
        }
    
    }
    
    /**
     * 购票的客户,客户为次要操作人,只要客户来了,由影院来发票,影院作为主要操作人
     */
    class HappyCustomer2 extends Thread{
    
    
        private List<Integer> buySeates;
    
        public HappyCustomer2(List<Integer> buySeates, Runnable cinemaLocal, String name) {
            super(cinemaLocal, name);
            this.buySeates = buySeates;
        }
    
        /**
         * 对外提供获得客户购买座位数的方法
         * @return
         */
        public List<Integer> getBuySeates() {
            return buySeates;
        }
    }
    /**
     * 定义本地影院的实体类
     */
    class CinemaLocal2 implements Runnable{
        /**
         * 座位集合以及名字
         */
        private List<Integer> seats;
        private String name;
    
        public CinemaLocal2(String name, List<Integer> seats) {
            this.name = name;
            this.seats = seats;
        }
    
        @Override
        public void run() {
            // 通过线程的强转可以获得到哪一个客户线程执行的影院线程
            HappyCustomer2 happyCustomer2 = (HappyCustomer2) Thread.currentThread();
            boolean isSuccess = saleTickets(happyCustomer2.getBuySeates());
    
            String buyCustomerName = Thread.currentThread().getName();
            if(isSuccess) {
                System.out.println(name + "成功售给客户" + buyCustomerName
                    + "票,共计:" + happyCustomer2.getBuySeates());
            }else {
                System.out.println(name + "无法售票给客户" + buyCustomerName + "票!");
            }
        }
    
        /**
         * 卖票
         * @param buySeats 购买的数量
         * @return
         */
        private synchronized boolean saleTickets(List<Integer> buySeats) {
    
            if(seats.size() <= 0) {
                return false;
            }
            // 集合之间的删除处理
            List<Integer> copySeats = copyList(seats);
    
            copySeats.removeAll(buySeats);
            if(copySeats.size() + buySeats.size() == seats.size()) {
                // 重新刷新影院剩余的票
                seats = copySeats;
                return true;
            }
            return false;
        }
    
        /**
         * 复制List集合
         * @param originalList
         * @param <T>
         * @return
         */
        private <T> List<T> copyList(List<T> originalList) {
            List<T> copyList = new ArrayList<>();
            copyList.addAll(originalList);
            return copyList;
        }
    }
    

     

    展开全文
  • 一、多线程 首先我们要清楚程序、进程、线程的关系。 首先进程从属于程序,线程从属于进程。 程序指计算机执行操作或任务的指令集合,是一个静态的概念。 ...

    一、多线程

    首先我们要清楚程序、进程、线程的关系。

    首先进程从属于程序,线程从属于进程。                                                                                                                           

    程序指计算机执行操作或任务的指令集合,是一个静态的概念。

    但我们实际运行程序时,并发程序因为相互制约,具有“执行——暂停——执行”的状态,

    显然这时程序这个静态的概念无法描述这种状态,从而人们引入了进程这个动态的概念分析研究程序的活动。

     

    目前国内对进程的定义:进程是指一个具有一定独立功能的程序关于某个数据集合的一次运行活动

    而线程从属于进程,线程是比进程更小的活动单位,它是进程中的一个执行路径。一个进程可以有多个执行路径,即多线程。

     

    二、java中多线程的实现

    1. 继承Thread实现多线程

    public class TestThread {
        public static void main(String args[]){
            Thre t1 = new Thre("线程1");
            Thre t2 = new Thre("线程2");
            t1.start();                   //多线程的调用并不是直接调用重写之后run方法
            t2.start();                   //而是通过start调用,start方法通过调用操作系统中的函数来实现资源的分配 
        }                                 //但实质是调用的还是run方法,只是中间通过了start方法。
    
    }
    class Thre extends Thread{ //要实现多线程需继承Thread类,并重写Thread中的run方法。
        private int i;         //run方法称为线程主体,是多线程运行时执行的部分。
        private String name;   
        
        public Thre(String name){
            this.name = name;
            
        }
        
        public void run(){
            for(i = 0; i < 10; i++){
                System.out.println(name +": "+ i);
            }
        }    
    }
    运行结果:
    线程2: 0
    线程1: 0
    线程2: 1
    线程1: 1
    线程2: 2
    线程2: 3
    线程2: 4
    线程2: 5
    线程1: 2
    线程1: 3
    线程1: 4
    线程1: 5
    线程1: 6
    线程1: 7
    线程1: 8
    线程1: 9
    线程2: 6
    线程2: 7
    线程2: 8
    线程2: 9

    可以看到最后的运行结果,是两个线程“同时”运行的,这里的同时是一种宏观上同时处理两个线程,但它们实质是是交替运行的的。

    这个举个例子,比如通信运营商要同时提供20个人通话,可以把一秒划分成1000ms,把第1、21、41.....(以此类推)ms给第一个用户使用,第2、22、42...ms给第二个用户使用

    由于间隔时间很短,用户察觉不到其中的间隔看起来像是连续的。从微观上看每一个ms只能服务一个用户,从宏观上来看是同时服务了20个用户。

    因为分时系统采用时间片轮转的方法来处理多线程,由于一个时间片很短,所以看起来像是同时运行。

     

    2.通过实现Runable接口来实现多线程

    在用接口实现多线程之前,需要了解一种模式:

    静态代理模式:

    静态代理模式实现的条件:

      2.1.真实角色

      2.2代理角色:(代理角色中还需要引用真实角色)

      2.3两者实现相同的接口

     

    下面我们举个例子

     1 public class Test{
     2     public static void main(String[] args) {
     3         My my = new My();
     4         MarryCompany user_my = new MarryCompany(my);//代理角色引用真实角色。
     5         user_my.marry();                            //最后结婚的是自己,但可以使用代理角色提供的服务。
     6     }
     7 }
     8 
     9 interface Marry{           //结婚功能的接口
    10     public void marry(); 
    11 }
    12 
    13 class My implements Marry{ //my是真实角色,要实现结婚接口
    14 
    15     @Override
    16     public void marry() {
    17         System.out.println("my 结婚");
    18     }    
    19 }
    20 
    21 class MarryCompany implements Marry{  //婚庆公司是代理角色也要实现结婚接口
    22     private Marry user;               //代理角色对真实角色的引用,首先在代理角色中创建真实角色。
    23     public MarryCompany(Marry user){
    24         this.user = user;
    25     }
    26     
    27     private void deadWork_1(){       //代理角色提供的一些服务(方法)。
    28         System.out.println("准备工作1");
    29     }
    30     
    31     private void deadWork_2(){
    32         System.out.println("准备工作2");
    33     }
    34         
    35     @Override
    36     public void marry() {            //代理角色中实现接口的方法。
    37             deadWork_1();            //代理角色提供的方法。
    38             deadWork_2();
    39             user.marry();            //真实角色结婚
    40     }    
    41 }
    运行结果:
    准备工作1
    准备工作2
    my 结婚

    就相当于与你要结婚,可以委托婚庆公司,这就是把代理角色引用真实角色(My my = new My();
    MarryCompany user_my = new MarryCompany(my);)最后是让婚庆公司代理一些事务,但最后结婚的还是自己。

    真实对象可以使用代理对象的一些方法,也可以说代理对象帮我做一些事情。

    和房产中介也是一样的,我们可以让代理角色(中介)帮我们提供一些它拥有的(方法)资源。

    但买房的还是我们自己。

     

    接着我们来看接口实现多线程,接口实现多线程也是使用的代理模式。

    首先回一下代理模式的三个条件

    1.真实对象

    2.代理对象(代理对象引用真实对象)

    3.实现相同的接口

    我们来看下Thread这个类的源码

    会发现Thread这个类实现了Runable接口。

    而Runable接口中有run方法。

     

    同时Thread提供了各种构造方法传递真实对象。(Runable接口作为类型)

     

    所以我们用接口实现多线程还需要如下步骤:

    1.真实角色(实现Runable接口)

    2.代理角色(引用真实角色,代理角色是Thread类)

     

     1 public class TestThread {
     2     public static void main(String args[]){
     3         Thre t1 = new Thre("线程1");  //创建真实角色,并分配一个名称便于查看
     4         Thre t2 = new Thre("线程2");
     5         Thread p_t1 = new Thread(t1); //代理角色对真实角色的引用
     6         Thread p_t2 = new Thread(t2);
     7         p_t1.start();                 //通过代理启动多线程,但实质上运行的还是真实角色。
     8         p_t2.start();
     9     }
    10 
    11 }
    12 
    13 
    14 class Thre implements Runnable{
    15     private int i;
    16     private String name;
    17     
    18     public Thre(String name){
    19         this.name = name;
    20         
    21     }
    22     
    23     public void run(){
    24         for(i = 0; i < 10; i++){
    25             System.out.println(name +": "+ i);
    26         }
    27     }    
    28 }

     

    运行结果:
    线程1: 0
    线程2: 0
    线程1: 1
    线程2: 1
    线程1: 2
    线程1: 3
    线程1: 4
    线程2: 2
    线程2: 3
    线程2: 4
    线程2: 5
    线程2: 6
    线程2: 7
    线程2: 8
    线程2: 9
    线程1: 5
    线程1: 6
    线程1: 7
    线程1: 8
    线程1: 9

     

     

     

    一般建议使用接口实现多线程:

    1.用接口实现多线程可以避免单继承的局限性。

    比如我有一个类要一定要继承别的类,那么就无法通过继承Thread来实现多线程了。

     

    2.可以资源共享

    这里举个例子,比如抢票。票的总数应该是被所以线程(用户)共享的。

    我们用传统的继承实现多线程来模拟简易抢票:

     1 public class TestThread {
     2     public static void main(String[] args) {
     3         My_12306 user1 = new My_12306("用户");
     4         My_12306 user2 = new My_12306("黄牛");
     5         user1.start();
     6         user2.start();
     7     }
     8 }
     9 
    10 
    11 class My_12306 extends Thread {
    12     private int ticket = 5;
    13     private String name;
    14     
    15     public My_12306(String name){
    16         this.name = name;
    17     }
    18     
    19     
    20     public void run(){
    21         for(int i = 0; i < 100; i++){
    22             if(ticket > 0)
    23                 System.out.println(name +"抢到了"+ ticket-- +"号票!");
    24         }
    25     }
    26 }
    运行结果:
    黄牛抢到了5号票!
    用户抢到了5号票!
    黄牛抢到了4号票!
    用户抢到了4号票!
    用户抢到了3号票!
    用户抢到了2号票!
    用户抢到了1号票!
    黄牛抢到了3号票!
    黄牛抢到了2号票!
    黄牛抢到了1号票!

    可以发现两个线程间的资源是独立的,每个用户都有5张票。

    结合下图理解

     

     

    如果我们用接口实现多继承来模拟抢票

     1 public class TestThread {
     2     public static void main(String[] args) {
     3         My_12306 m12306 = new My_12306();
     4         
     5         Thread user_1 = new Thread(m12306,"用户");
     6         Thread user_2 = new Thread(m12306,"黄牛");
     7         user_1.start();
     8         user_2.start();
     9     }
    10 }
    11 
    12 
    13 class My_12306 implements Runnable {
    14     private int ticket = 10;
    15     private String name;
    16     
    17     public My_12306(){}
    18     
    19     public My_12306(String name){
    20         this.name = name;
    21     }
    22     
    23     
    24      public void run(){
    25         for(int i = 0; i < 100; i++){
    26                 if(ticket > 0){
    27                     System.out.println(Thread.currentThread().getName() +"抢到了"+ ticket-- +"号票!");    
    28             }
    29         }
    30     }
    31 }
    运行结果:
    用户抢到了10号票!
    黄牛抢到了10号票!
    黄牛抢到了9号票!
    用户抢到了8号票!
    用户抢到了6号票!
    用户抢到了5号票!
    用户抢到了4号票!
    用户抢到了3号票!
    用户抢到了2号票!
    用户抢到了1号票!
    黄牛抢到了7号票!

    可以看到用接口实现多线程可以实现资源共享,第10号票同时被用户和黄牛抢走,

    这是因为线程执行速度太快,资源又没有同步导致的,这就涉及到后面的同步问题。

     

    结合下图理解

     

    转载于:https://www.cnblogs.com/huang-changfan/p/9433959.html

    展开全文
  • 静态代理模式 //静态代理模式总结: //真实对象和代理对象都要实现同一个接口 //代理对象要代理真实角色 //好处: //代理对象可以做很真实对象做不了的事情 //真实对象专注做自己的事情 public class ...
  • 动态代理:就是临时构建起来的类,静态代理:可以理解为已经写好的类,直接拿来用; 代理随处可见,比如你结婚,婚庆公司给你准备好一切,但是...我们用静态代理模式来模拟婚庆公司: package com.jianshun.thr...
  • 文章目录一、静态代理二、多线程中的静态代理模式 一、静态代理 静态代理实现的条件:真实角色,代理角色,两者实现相同的接口 就相当于买房,可以委托房产中介,这就是把代理角色引用真实角色 My my = new My(); //...
  • 众所周知,java多线程有两种实现方法: 1、继承Thread类、重写run()方法。 2、实现runnable接口、重写run()方法。 但是其实Thread类也是实现了runnable接口的run()方法。 这种设计模式称之为代理模式: ...
  • 静态代理模式 举个简单的例子 你:真实的角色 婚庆公司:代理你,能帮你处理一些结婚的事,布置现场之类的。 结婚:你需要做的事,但婚婚庆公司也会参与 package lessen05; /** * 静态代理模式 * 真实对象和...
  • 实现静态代理模式: package ThreadTest; //静态代理模式: //真实对象和代理对象都要实现同一个接口 //代理对象要代理真实角色 //好处: //代理对象可以做很真实对象做不了的事情 //真实对象专注做自己的事情 ...
  • 文章目录前言线程的创建方式静态代理模式Lambda 表达式停止线程线程休眠观察线程状态线程优先级守护线程 前言 之前线程的概念已经有总结过,这里主要总结 Java 线程类的创建方式,以及实现同步和互斥 另外也会剖析...
  • 进程和线程 程序:静态概念 进程:程序的一次运行过程,动态概念,是系统资源分配的...推荐使用runnaable接口实现多线程 原因:避免oop单继承的局限性,接口可以继承多个接口,灵活方便,方便同一个对象被多个线程使...
  • 所以接下来讲的就是静态代理模式 * 静态代理 设计模式 * 1.真实角色 * 2.代理角色:持有真实角色的引用 * 3.二者要实现相同的接口 举这样一个例子,买房的客户以及房屋中介 客户即真实角色,中介即代理角色,你把...
  • 首先来介绍下Java实现多线程的两种方式  继承Thread类方式和通过Runnable接口的方式  继承Thread类方式的缺点:如果我们的类已经继承了其他类,那就无法再继承Thread类了  实现Runnable接口的方式优点:避免了...
  • 目录静态代理模式lambda 表达式 在前面使用Runnable 接口创建线程的时候,使用到了Thread 类的静态代理模式,把这段代码再拿出来看看。 public class Test2 implements ... System.out.println("我在学习多线程"+i); }
  • * 静态代理设计模式 * 1.有真实角色 * 2.有代理角色:持有真实角色的引用 * 3.要求:二者要实现相同的接口 * @author Admin * */ public class StaticProxy { public static void main(Stri...
  • 静态代理属于设计模式中的代理模式。反之则有动态代理,本篇文章不展开讲,有兴趣的可自行谷歌研究研究。 其实继承Thread也属于静态代理的一种,所以在这里学习静态代理有助于我们学习多线程。 一、静态代理 实际...
  • Java/Python】多线程

    2020-05-12 10:26:58
    多线程编程基础Java多线程创建线程继承Thread + 重写run(线程体)通过Runnable接口实现多线程静态代理设计模式通过Calllable接口实现多线程线程的状态和方法停止线程阻塞线程的同步和死锁问题单例设计模式死锁生产者...
  • 静态代理模式: 1.真实对象和代理对象都要实现同一个接口 2.代理对象要代理真实角色 3.好处就是代理对象可以做很真实对象做不了的事 个人理解: 考虑代理的过程,肯定要有一个真实对象,比如结婚的你;还要有一个...
  • Java多线程:静态代理

    2021-02-21 17:03:11
    代理模式是一种设计模式,提供了对目标对象额外的访问方式,即通过代理对象访问目标对象,这样可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能。 简言之,代理模式就是设置一个中间代理来...
  • java实现多线程的方式二,实现Runable接口用到设计模式——静态代理模式 一.代理模式 代理模式的定义  代理模式(Proxy Pattern)是对象的结构型模式,代理模式给某一个对象提供了一个代理对象,并由...
  • Java多线程之静态代理

    2018-09-18 15:37:00
    1 package org.study2.java... 4 * @Date:2018-09-18 静态代理 设计模式 5 * 1、真实角色 6 * 2、代理角色:持有真实角色的引用 7 * 3、二者实现相同的接口 8 * 举例说明:Couple类和Company类都实现了Mar...
  • Java-多线程-2 学习视频:B站 狂神说Java – https://www.bilibili.com/video/BV1V4411p7EF 学习博客:csdn – https://blog.csdn.net/yalu_123456/article/details/91049333?spm=1001.2014.3001.5501 4、静态代理...
  • java多线程

    2019-01-25 21:03:59
    多线程的状态 多线程的创建 1继承Thread类,重写run方法(缺点:java单继承多实现,...静态代理模式 真实角色(租房者) 代理角色(中介公司)持有真实对象的引用 两者需实现同一个接口 在代理角色里面创建真实角色...
  • 多线程相关 实现多线程的时候: 1,需要继承Thread类 2,必须要重写run()方法 ...第二种实现方式:(使用了代理设计模式) 1,实现Runnable接口 2,重写run方法 3,创建Thread对象,将刚刚创建好的runnabl...
  • Java多线程详解(一)轻松学习Java多线程(一)1、 线程简介2、线程的创建2.1 三种创建方式2.2 Thread2.3 实现Runnable2.3.1 初识并发问题2.3.2 案例:龟兔赛跑2.4 实现Callable接口3、静态代理模式4、Lambda表达式...
  • Java多线程

    2020-02-07 17:54:29
    实现多线程的方法 1.重写Thread类的run()方法 2.实现Runable接口的rum方法,再Thread(runable) 静代理模式 package 静态代理; public class Demo { public static void main(String[] args) { WeddingCompany ...
  • thread实现thread用 thread 实现线程实现 runnable 接口(推荐)实现Callable接口案例模拟龟兔赛跑静态代理模式动态代理模式Lambda表达式无参lambda表达式带参lambda表达式线程停止线程休眠线程礼让join插队线程状态...
  • N10 多线程(一) 作者:迷恋 一、线程、进程、多线程概要 二、继承Thread类 三、实现Runnable接口 四、实现Callable接口(了解即可) 五、静态代理模式

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 273
精华内容 109
关键字:

java实现代理模式多线程

java 订阅