精华内容
下载资源
问答
  • 其实继承Thread也属于静态代理的一种,所以在这里学习静态代理有助于我们学习多线程。 一、静态代理 实际案例:买房 买房人 我 买房办理人 中介 共同的行为 买房 代码实现案例: class MyI implements ...

    前言

    静态代理属于设计模式中的代理模式。反之则有动态代理,本篇文章不展开讲,有兴趣的可自行谷歌研究研究。
    其实继承Thread也属于静态代理的一种,所以在这里学习静态代理有助于我们学习多线程。

    一、静态代理

    • 实际案例:买房

      • 买房人 我
      • 买房办理人 中介
      • 共同的行为 买房
    • 代码实现案例:

    class MyI implements BuyHouse {
    
        //对我来说,我只需负责拿钱,签字即可
        @Override
        public void Buy() {
            System.out.println("一百万,签合同,房子是我的了!");
        }
    }
    
    class Agent implements BuyHouse{
        private BuyHouse buyHouse;
        
        public Agent(BuyHouse buyHouse){
            this.buyHouse = buyHouse;
        }
    
        //先帮我准备合同等材料
        public void work1(){
            System.out.println("准备合同等材料~");
        }
        //带我去房管局办理手续
        public void work2(){
            System.out.println("带着客户去办手续~");
        }
    
        //中介收了我的钱,他得帮我准备购房材料,带着我跑购房流程等等
        @Override
        public void Buy() {
            work1();
            work2();
            //客户买房
            buyHouse.Buy();
        }
    }
    
    • 执行结果如下:
      在这里插入图片描述

    • 结论:

      • 本质上还是相当于把业务分开,降低程序的耦合性,不管是中介还是我,最终的目的都是买房,我只关注于买房的业务,其他业务无需管,而中介需要准备材料,准备合同,带我去房管局等一系列流程。

    Java多线程扩展:Java多线程学习汇总

    路漫漫其修远兮,吾必将上下求索~
    如果你认为i博主写的不错!写作不易,请点赞、关注、评论给博主一个鼓励吧**转载请注明出处哦**

    展开全文
  • 线程中的静态代理模式 实现多线程的三种方式 继承Thread类 【Thread类实现了Runnable接口】 实现Runnable接口 实现Callable接口 静态代理模式例子 静态模式三部分组成: 1.共同实现的接口 2.被代理目标 3.代理 ...

    1、实现多线程的三种方式

    1. 继承Thread类 【Thread类实现了Runnable接口】
    2. 实现Runnable接口
    3. 实现Callable接口

    2、静态代理模式例子

    静态模式三部分组成:
    1.共同实现的接口
    2.被代理目标
    3.代理

    • 例 :你结婚,需要找一个婚庆公司,帮你布置婚礼现场等。这个时候,你 就是被代理对象,婚庆公司就是代理,而结婚就是那个被共同实现的接口。
    /**
     * @deprecated 静态代理
     *
     * 1.真实角色 (被代理目标) 本文中的 class You
     * 2.代理  本文中的 class WeddingCompany
     * 3.接口  本文中的 interface Marry
     *
     **/
    public class StaticProxy {
    	//测试
        public static void main(String[] args) {
    		//把目标 你 传给 婚庆公司
            WeddingCompany weddingCompany = new WeddingCompany(new 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();
        }
    
        private void after() {
            System.out.println("结婚之前,布置会场");
        }
    
        private void before() {
            System.out.println("结婚之后,收取尾款");
        }
    }
    

    3、多线程中的Thread类与例子的对比

    • 创建一个线程
    public class ThreadStudy extends Thread{
    	
        new Thread(() -> System.out.println("结婚")).start();
    }
    

    Thread源码浅析(跟结婚例子对比)

    • 在new Thread的时候 ,类似于例子中的 new WeddingCompany(new You());
    • WeddingCompany类实现了Marry接口,Thread类实现了Runnable接口
      在这里插入图片描述
    • Marry接口中定义了 HappyMarry();方法,Runnable接口中定义了run();方法
      在这里插入图片描述
    • 例子中是调用HappyMarry()实现静态代理,Thread是调用接口中的run方法实现静态代理。

    总结

    • 静态代理三要素: 1.接口(会被代理与被代理共同实现) 2、代理 3、被代理目标
    • Thread的静态代理实现流程
      1.创建目标对象,并实现与Thread类共同实现的接口Runnable接口。
      2.将目标对象传给Thread。
      3.调用接口中的run方法
    展开全文
  • 简单学习多线程有力的好帮手,我也是刚刚学习总结的自己的经验 希望大家借鉴,
  • 创建线程的另一种方法是声明实现 Runnable 接口的类。该类实现 run 方法。然后可以分配该类的实例,在创建 Thread 时作为一个参数来传递并启动 先创建一个Programmer类继承Runnable...启动多线程 使用静态代理 * ...

    创建线程的另一种方法是声明实现 Runnable 接口的类。该类实现 run 方法。然后可以分配该类的实例,在创建 Thread 时作为一个参数来传递并启动

    先创建一个Programmer类继承Runnable,重写Run方法

    /*
     * 使用Runnable创建线程
     * 1.类实现Runnable接口+重写run() --->真实角色类
     * 2.启动多线程 使用静态代理
     * 	1)创建真实角色
     * 	2)创建代理角色+真实角色引用
     * 	3)调用start()方法启动线程
     */
    public class Programmer implements Runnable{
    
    	@Override
    	public void run() {
    		for (int i=0;i<1000;i++){
    			System.out.println("一边敲代码。。。");
    		}
    		
    	}
    
    }
    

    然后下列代码会创建并启动一个线程

    public class ProgrammerApp {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    //		创建真实角色
    		Programmer pro = new Programmer();
    //		创建代理角色+真实角色引用
    		Thread proxy = new Thread(pro);
    //		调用start()方法启动线程
    		proxy.start();
    //创建另一个线程进行测试		
    		for (int i=0;i<1000;i++){
    			System.out.println("一边上网。。。");
    		}
    	}
    
    }

    运行时,“一边敲代码。。”和”一边上网。。“两个线程同时进行

    推荐使用Runnable:避免单继承的局限性,便于共享资源

    展开全文
  • Java多线程 基础学习笔记 / 学习静态代理模式-附件资源
  • (二)静态代理举例 (三)实际运用 (四)与Thread创建线程的优缺点   (一) 必须实现Runnable+run()方法 启动:使用静态代理。 1、创建真实角色 2、创建代理角色 Thread+引用 3、代理角色.start (二)静态...

      目录:
    (一)启动步骤
    (二)静态代理举例
    (三)实际运用
    (四)与Thread创建线程的优缺点

     

    (一)
    必须实现Runnable+run()方法
    启动:使用静态代理
    1、创建真实角色
    2、创建代理角色 Thread+引用
    3、代理角色.start

    (二)静态代理举例(婚庆中介)

    /**
     * 静态代理设计模式
     * 1、真实角色
     * 2、代理角色:持有真实角色的引用
     * 3、要求:二者实现相同的接口
     * @author john
     *
     */
    public class StaticProxy {
    	public static void main(String[] args){
    		//创建真实角色
    		You you=new You();
    		//创建代理角色+真实角色的引用
    		WeddingCompany company=new WeddingCompany(you);
    		//执行任务
    		company.marry();
    		
    	}
    }
    
    //接口
    interface Marry{
    	public abstract void marry();
    }
    //真实角色
    class You implements Marry{
    	public void marry(){
    		System.out.println("you and me marry");
    		 
    	}
    }
    //代理角色
    class WeddingCompany implements Marry{
    	private Marry you;
    	public WeddingCompany(){
    		
    	}
    	public WeddingCompany(Marry you){
    		this.you=you;
    	}
    	private void before(){
    		System.out.println("买房买车");
    	}
    	private void after(){
    		System.out.println("生孩子!");
    		
    	}
    	public void marry(){
    		before();
    		after();
    		you.marry();
    	}
    }
    

    (三)运用举例:12036购票网站

    /**
     * 利用Runnable接口,资源共享,模拟购票
     * @author john
     *
     */
    public class Web12306 implements Runnable{
    	private int num=50;
    	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();
    
    	}
    
    }
    

    (四)推荐实现Runnable接口
    继承Thread类的缺点:我们的类已经从一个类继承(如小程序必须继承自Applet类),则无法再继承Thread类。
    实现Runnable接口优点: 1)避免单继承的局限性   2)便于共享资源(如上述12306购票)

    展开全文
  • 首先来介绍下Java中实现多线程的两种方式  继承Thread类方式和通过Runnable接口的方式  继承Thread类方式的缺点:如果我们的类...那么下面就来说说静态代理模式  代理就比如是找房子可以找中介,结婚可以找婚庆公司
  • 静态代理

    2021-04-13 09:53:42
    静态代理 public class TestThread4 implements Runnable{ @Override public void run() { for (int i = 0; i < 20; i++) { System.out.println("执行了方法体"); } } public static void main(String[] ...
  • 一、S02E169_01线程_概念二、S02E170_01线程创建之一_继承Thread三、S02E171_01静态代理模式四、S02E172_01线程创建之二_接口Runnable五、S02E173_01线程创建之三_接口Callable
  • Java静态代理

    千次阅读 2019-05-01 21:02:20
    在使用Runnable接口实现多线程的时候,启动必须借助Thread对象,我们将这个Thread对象称之为代理对象(静态代理)。在开发中一般用于记录日志、增强服务等,其对应的是动态代理,后面再行学习。
  • public class TestThread4 implements Runnable { int tickerNum = 10; @Override public void run() { while(true){ if(tickerNum<=0){ break;... System.out.println(Thread.currentThread().getName()+"抢...
  • 代理模式(Proxy Pattern)是一种结构性模式。代理模式为一个对象提供了一个替身,以控制对这个对象的访问。即通过代理对象访问目标目标对象,可以在目标对象实现的基础上,增强额外...静态代理 动态代理 cglib代理 应用
  • java 多线--静态代理模式 我们使用 java 多线程时,都需要通过线程代理对象来启动线程,常见的写法: new Thread(target).start(); 这在设计模式中叫静态代理模式,静态代理模式组成; 1、公共接口 2、真实角色 3、...
  • 静态代理的意义和用法

    千次阅读 2017-10-17 19:51:43
    什么是静态代理?用通俗的话讲就是在我设计程序的时候,只需要一个实现了固定接口的实现类,我并不关心具体是哪个类。当然仅仅要实现这个功能的话,通过接口的回调,同样可以实现,静态代理还可以进行预处理和事后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,168
精华内容 39,267
关键字:

线程静态代理