线程--继承类实现了静态代理模式

最新推荐文章于 2022-11-13 15:10:35 发布
最新推荐文章于 2022-11-13 15:10:35 发布
阅读量300 收藏 1
点赞数
分类专栏： java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012532092/article/details/78324799
版权
1、概述

这里写图片描述

这里写图片描述
这里写图片描述
这里写图片描述

（看最后一个图）
进程包含线程；线程是进程的一部分，是轻量级的进程，是不同的执行路径。
多线程：一条路径不能满足要求，另开辟一条路径。
真正的多线程是有多个cpu，有多核。cpu调度哪个程序哪段代码有个调度，调度过程中有个时间片(纳秒级别)。把线程a挂起，再执行线程b，时间片非常的短，看起来像是a和b同时在执行。
什么时候需要执行多线程？
main方法(主线程)执行的时候，还有后台默默执行的gc，这个就是多线程；
异常机制；

2、java实现多线程

就是一些类和接口
这里写图片描述
模拟多线程：

/**
 * 模拟龟兔赛跑
 1、创建多线程  继承  Thread  +重写run(线程体)
 2、使用线程: 创建子类对象 + 对象.start() ，这表示线程启动，线程启动不表示线程运行

 (调用start()方法，加到线程组里面去了。 它内部由cpu去管控它，cpu去调用它。
 而且不要去调用线程类的run方法，那不叫启动线程，而是方法调用。)
    总之：想开辟一条新路径，必须调用start()方法，加到线程组里面，由cpu自己管控。
 * 
 * @author Administrator
 *
 */
public class Rabbit extends Thread {

    @Override
    public void run() {
        //线程体
        for(int i=0;i<100;i++){
            System.out.println("兔子跑了"+i+"步");
        }
    }
}
class Tortoise extends Thread {

    @Override
    public void run() {
        //线程体
        for(int i=0;i<100;i++){
            System.out.println("乌龟跑了"+i+"步");
        }
    }
}


public class RabbitApp {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建子类对象
        Rabbit rab = new Rabbit();
        Tortoise tor =new Tortoise();


        //调用start 方法
        rab.start(); //不要调用run方法,这个run方法是内部自己调用
        //rab.run();
        tor.start();
        //tor.run();

        //这里一共是5条路，加上main，后台的gc和异常。

        for(int i=0;i<1000;i++){
            System.out.println("main==>"+i);
        }
    }
}

这里写图片描述

这种方式实现了静态代理模式。run方法不能对外声明异常

package com.bjsxt.thread.create;
/**
 * 静态代理 设计模式
 * 1、真实角色   
 * 2、代理角色： 持有真实角色的引用  （婚介忙前忙后，但结婚的人还是你）
 * 3、二者 实现相同的接口  （你租房子找中介公司、你结婚找婚介）
 * 中介公司帮你找房子，代理角色帮真实角色实现相同的接口
 * @author Administrator
 *
 */
public class StaticProxy {
    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建真实角色，这里没有新增方法，就可以用接口
        Marry you =new You();
        //创建代理角色 + 真实角色的引用（这里可以用set和get方法，也可以用构造器）
        WeddingCompany company =new WeddingCompany(you);
        //执行任务
        company.marry();
    }

}
//接口
interface Marry{
    //void marry();可以省略
    public abstract void marry();
}
//真实角色
class You implements Marry{
    @Override
    public void marry() {
        System.out.println("you and  嫦娥结婚了....");
    }

}
//代理角色
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("闹玉兔....");
    }
    @Override
    public void marry() {
        before();
        you.marry();
        after();
    }
}

Thread类实现了Runnable接口，Thread类就是代理角色，我们创建一个真实角色就可以了。
真实角色实现Runnable接口+Thread(Runnable target)代理持有真实角色的引用 = 符合代理模式
源码中：run()方法，如果target!=null，就执行target的run()方法。
代理可以有多个，表示资源可以共享

package com.bjsxt.thread.create;
/**
 * 方便共享资源
 * @author Administrator
 *
 */
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();
    }
}

创建多线程总结：
这里写图片描述

这里写图片描述

package com.bjsxt.thread.create;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * 使用Callable创建线程
 * @author Administrator
 *
 */
public class Call {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建线程
        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("乌龟跑了-->"+num1+"步");
        System.out.println("小兔子跑了-->"+num2+"步");
        //停止服务 
        ser.shutdownNow();

    }
}

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

    public Race(String name) {
        super();
        this.name = name;
    }
    public Race(String name,long time) {
        super();
        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;
    }

}
3、线程状态

start()之后 线程进入就绪状态，等待CPU调度
就绪，运行，阻塞状态 都是线程是 活的，其余的都是死的，new出来没有启动也是死的。

这里写图片描述

创建状态：new一下即可
就绪状态：调用start就进入就绪了
运行状态：cpu调度了

终止：线程体执(run方法)行完毕。 下面看线程怎么停止
这里写图片描述

这里写图片描述

package com.bjsxt.thread.status;

public class StopDemo01 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Study s =new Study();
        new Thread(s).start();

        //外部干涉
        for(int i=0;i<100;i++){
            if(50==i){ //外部干涉
                s.stop();
            }
            System.out.println("main.....-->"+i);
        }
    }
}
class Study implements Runnable{
     //1)、线程类中 定义 线程体使用的标识   
    private boolean flag =true;
    @Override
    public void run() {
        //2)、线程体使用该标识
        while(flag){
            System.out.println("study thread....");
        }
    }
    //3)、对外提供方法改变标识
    public void stop(){
        this.flag =false;
    }
}

这里写图片描述
阻塞：

join：合并线程. （等合进来的运行完了。）
主线程中插一个 线程t，t.join表示，线程t合入到主线程中，等t执行完了再执行主线程，和方法调用效果一样。

package com.bjsxt.thread.status;
/**
 * join:合并线程
 * @author Administrator
 *
 */
public class JoinDemo01 extends Thread {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        JoinDemo01 demo = new JoinDemo01();
        Thread t = new Thread(demo); //新生成的线程
        t.start();//就绪
        //cpu调度 运行


        for(int i=0;i<1000;i++){
            if(50==i){
                t.join(); //main阻塞...    等于50的时候，让demo执行完毕，再执行main线程
            }
            System.out.println("main...."+i);
        }
    }

    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println("join...."+i);
        }
    }

}

yield：暂停自己的线程（后面可能还会被调度），（静态方法）（写在谁的线程体里面就暂定谁） （让合进来的运行一会儿）

package com.bjsxt.thread.status;

public class YieldDemo01 extends Thread {

    /**
     * @param args
     */
    public static void main(String[] args) {
        YieldDemo01 demo = new YieldDemo01();
        Thread t = new Thread(demo); //新生
        t.start();//就绪
        //cpu调度 运行


        for(int i=0;i<1000;i++){
            if(i%20==0){
                //暂停本线程 main
                Thread.yield();
            }
            System.out.println("main...."+i);
        }
    }

    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println("yield...."+i);
        }
    }

}

sleep：休眠，（静态方法）不释放锁。
倒计时：

package com.bjsxt.thread.status;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 倒计时
 * 1、倒数10个数，一秒内打印一个
 * 2、倒计时
 * @author Administrator
 *
 */
public class SleepDemo01 {
    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        Date endTime =new Date(System.currentTimeMillis()+10*1000);
        long end =endTime.getTime();
        while(true){
            //输出
            System.out.println(new SimpleDateFormat("mm:ss").format(endTime));  //format格式化为字符串，parse转换为日期
            //等待一秒,顺序也可以放在下面
            Thread.sleep(1000);
            //构建下一秒时间
            endTime =new Date(endTime.getTime()-1000);
            //10秒以内 继续 否则 退出
            if(end-10000>endTime.getTime()){
                break;
            }
        }
    }
    public static void test1() throws InterruptedException{
        int num =10;
        while(true){
            System.out.println(num--);
            Thread.sleep(1000); //暂停
            if(num<=0){
                break;
            }
        }
    }
}

网络延迟：

package com.bjsxt.thread.status;


/**
 * Sleep模拟 网络延时  线程不安全的类
 * @author Administrator
 *
 */
public class SleepDemo02 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //真实角色
        Web12306 web= new Web12306();
        Web12306 web2 = new Web12306();
        //代理
        Thread t1 =new Thread(web,"路人甲");
        Thread t2 =new Thread(web,"黄牛已");
        Thread t3 =new Thread(web,"攻城师");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }

}

class Web12306 implements Runnable {
    private int num =50;

    @Override
    public void run() {
        while(true){
            if(num<=0){
                break; //跳出循环
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
        }
    }
}

线程状态：
这里写图片描述

设置优先级
/**
 * 优先级:概率，不是绝对的先后顺序
   MAX_PRIORITY  10
   NORM_PRIORITY 5 (默认)
   MIN_PRIORITY  1

   setPriority()
   getPriority()
 * @author Administrator
 *
 */
4、线程同步：

这里写图片描述
这里写图片描述
java.util.Hashtable - 线程安全的，同步的
StringBuffer – 也是线程安全的，使用了synchronized。这个关键字就是锁，任何线程访问这个方法，先获得这个方法的锁，锁住了门一关别人就访问不了
等线程锁释放了，别的锁才能进来。线程体执行完毕，锁自然就释放了。
访问同一个资源才会有并发问题，访问不同的资源没事。
一般地线程不安全的效率比较高。
JDK的RunTime就是单例中饿汉

package com.bjsxt.thread.syn;


public class SynDemo01 {
    /**
     * @param args
     */
    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();
    }
}
/**
 * 线程安全的类
 * @author Administrator
 *
 */
class Web12306 implements Runnable {
    private int num =10;
    private boolean flag =true;
    @Override
    public void run() {
        while(flag){
            test5();
        }
    }

    //线程不安全 锁定范围不正确
    public void test6(){

        if(num<=0){
            flag=false; //跳出循环
            return ;
        }
         //a  b  c  
        synchronized(this){
            try {
                Thread.sleep(500); //模拟 延时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
        }
    }

    //线程不安全  锁定资源不正确
    public void test5(){
        //a  b  c
        synchronized((Integer)num){
            if(num<=0){
                flag=false; //跳出循环
                return ;
            }
            try {
                Thread.sleep(500); //模拟 延时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
        }
    }



    //锁定范围不正确 线程不安全
    //锁定范围小了
    public void test4(){
        //   c  1
        synchronized(this){
            //b
            if(num<=0){
                flag=false; //跳出循环
                return ;
            }
        }
        // b
        try {
            Thread.sleep(500); //模拟 延时
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
    }//a -->1

    //线程安全  锁定正确
    public void test3(){
        //a  b  c   abc进来只能是依次地等待
        //锁定this，this指的是对象
        synchronized(this){
            if(num<=0){
                flag=false; //跳出循环
                return ;
            }
            try {
                Thread.sleep(500); //模拟 延时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
        }
    }
    //线程安全  锁定正确
    public synchronized void test2(){
        if(num<=0){
            flag=false; //跳出循环
            return ;
        }
        try {
            Thread.sleep(500); //模拟 延时
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
    }

    //线程不安全
    public void test1(){
        if(num<=0){
            flag=false; //跳出循环
            return ;
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
    }
}

package com.bjsxt.thread.syn;
/**
 * 单例设计模式:确保一个类只有一个对象
 这个对象由类内部创建，外部只能使用这一个对象（JVM只有一个吧，其它类都是对它的引用）
 GC..
 * @author Administrator
 *
 */
public class SynDemo02 {
    /**
     * @param args
     */
    public static void main(String[] args) {
        JvmThread thread1 = new JvmThread(100);
        JvmThread thread2 = new JvmThread(500);
        thread1.start();
        thread2.start();
    }
}

class JvmThread extends Thread{
    private long time;
    public JvmThread() {
    }
    public JvmThread(long time) {
        this.time =time;
    }
    @Override
    public void run() {     
        System.out.println(Thread.currentThread().getName()+"-->创建:"+Jvm.getInstance(time));
    }
}


/**
 * 单例设计模式（的套路）
 * 确保一个类只有一个对象
 * 懒汉式  double checking（经典的双重检查）
 * 1、构造器私有化,避免外部直接创建对象
 * 2、声明一个私有的静态变量
 * 3、创建一个对外的公共的静态方法 访问该变量，如果变量没有对象，创建该对象
 */
class Jvm {
    //声明一个私有的静态变量
    private static Jvm instance =null;    //懒得去创建对象
    //构造器私有化,避免外部直接创建对象
    private Jvm(){

    }
    //对getInstance3的改进
    //创建一个对外的公共的静态方法 访问该变量，如果变量没有对象，创建该对象
    public static Jvm getInstance(long time){
        // c d e  -->效率  提供 已经存在对象的访问效率（线程不需要等待）
        if(null==instance){ 
            // a b 。a创建了，b进来发现有对象了，就不必等其他线程拿到对象之后它才可以拿，b直接拿对象就行
            synchronized(Jvm.class){
                if(null==instance ){
                    try {
                        Thread.sleep(time); //延时 ，放大错误。才会加一个time
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance =new Jvm();
                }
            }
      }//a
      return instance;
    }

    //这里是同步块
    public static Jvm getInstance3(long time){
        //a b c d e  -->效率不高 c  存在对象也需要等待
        //任何时候要获取对象，如果对象存在的话，那也要进下面的方法，也要等待。锁定的是对象，线程b必须等线程a拿到对象之后才可以拿对象，有了一个等待的时间
        //这里不能用this，因为静态方法里面没有this
        synchronized(Jvm.class){
            if(null==instance ){
                try {
                    Thread.sleep(time); //延时 ，放大错误
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance =new Jvm();
            }
            return instance;
        }
    }

    //这里是同步方法
    public static synchronized Jvm getInstance2(long time){
        if(null==instance ){
            try {
                Thread.sleep(time); //延时 ，放大错误
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance =new Jvm();
        }
        return instance;
    }

    //问题：单线程里面new出来的始终是一个对象，多线程的话就要加synchronized
    public static Jvm getInstance1(long time){
        if(null==instance ){
            try {
                Thread.sleep(time); //延时 ，放大错误
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //两个线程进来，就有可能创建两个对象
            instance =new Jvm();
        }
        return instance;
    }
}
package com.bjsxt.thread.syn;
/**
 * 单例创建的方式
 * 1、懒汉式
 * 1)、构造器私有化
 * 2)、声明私有的静态属性
 * 3)、对外提供访问属性的静态方法，确保该对象存在
 * 
 * @author Administrator
 *
 */
 //懒汉式
public class MyJvm {
    private static MyJvm instance;
    private MyJvm(){

    }
    //多线程的难点：又要提高效率，又要注意安全
    public static MyJvm getInstance (){
        if(null==instance){ //提供效率
            synchronized(MyJvm.class){
                if(null==instance){ //安全
                    instance =new MyJvm();
                }
            }
        }
        return instance;
    }
}
/**
 * 饿汉式
   1)、构造器私有化 
 * 2)、声明私有的静态属性,同时创建该对象
 * 3)、对外提供访问属性的静态方法
 * @author Administrator
 *
 */
class MyJvm2 {
    //这里是线程安全的，
    //加载MyJvm2的时候instance就初始化
    private static MyJvm2 instance =new MyJvm2();
    private MyJvm2(){

    }
    public static MyJvm2 getInstance (){        
        return instance;
    }

}
/**
 * 类在使用的时候加载 ，延缓加载时间
 * @author Administrator
 *
 */
class MyJvm3 { //对MyJvm2的改进，提升效率的
    //内部类   
    //加载MyJvm3的时候不一定会加载JVMholder，只有用到的时候（这里是调用getInstance时）加载。不调用该方法，JVMholder永远不会被加载
    //可以延缓加载时间
    private static class JVMholder{
        private static MyJvm3 instance =new MyJvm3();
    }
    private MyJvm3(){

    }
    public static MyJvm3 getInstance (){        
        return JVMholder.instance;
    }

}

死锁：过多的同步造成死锁
即：不给我钱我不给你货，你不给我货我就不给你钱
同一份资源，在线程A中用了，又在线程B中用了，就可能会造成死锁。互相不释放

package com.bjsxt.thread.syn;
/**
 * 过多的同步方法可能造成死锁
 * @author Administrator
 *
 */
public class SynDemo03 {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Object g =new Object();
        Object m = new Object();
        Test t1 =new Test(g,m);
        Test2 t2 = new Test2(g,m);
        Thread proxy = new Thread(t1);  //多态不能调用新增方法
        Thread proxy2 = new Thread(t2);
        proxy.start();
        proxy2.start();
    }

}
class Test implements Runnable{
    Object goods ;
    Object money ;

    public Test(Object goods, Object money) {
        super();
        this.goods = goods;
        this.money = money;
    }

    @Override
    public void run() {
        while(true){
            test();
        }
    }

    public void test(){
        synchronized(goods){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(money){

            }
        }
        System.out.println("一手给钱");
    }
}

class Test2  implements Runnable{
    Object goods ;
    Object money ;
    public Test2(Object goods, Object money) {
        super();
        this.goods = goods;
        this.money = money;
    }

    @Override
    public void run() {
        while(true){
            test();
        }
    }

    public void test(){
        synchronized(money){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(goods){    
            }
        }
        System.out.println("一手给货");
    }
}

生产者消费者模式（不是设计模式，是解决多线程的问题）
如何解决死锁，看看生产者消费者模式。
先生产再消费，有东西了再消费，没有东西先生产（用的是同一份资源）
这里写图片描述

package com.bjsxt.thread.pro;
/**
 一个场景,共同的资源
  生产者消费者模式 信号灯法
 wait() :等待，释放锁  。 sleep 不释放锁
 notify()/notifyAll():唤醒
   他俩必须要与 synchronized一起使用
 * @author Administrator
 *
 */
public class Movie {
    private String pic ;
    //信号灯
    //flag -->T 生产生产，消费者等待 ，生产完成后通知消费
    //flag -->F 消费者消费 生产者等待, 消费完成后通知生产
    private boolean flag =true;
    /**
     * 播放
     * @param pic
     */
    public synchronized void play(String pic){
        if(!flag){ //生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //开始生产
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("生产了:"+pic);  //生产了左青龙
        //生产完毕      
        this.pic =pic;
        //通知消费
        this.notify();
        //生产者停下
        this.flag =false;
    }

    public synchronized void watch(){
        if(flag){ //消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //开始消费
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消费了"+pic);
        //消费完毕
        //通知生产
        this.notifyAll();
        //消费停止
        this.flag=true;
    }
}
5、任务调度

这里写图片描述

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
    了解
  Timer() 
  schedule(TimerTask task, Date time) 
  schedule(TimerTask task, Date firstTime, long period) 
  自学 quartz
 * @author Administrator
 *
 */
public class TimeDemo01 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Timer timer =new Timer();
        timer.schedule(new TimerTask(){

            @Override
            public void run() {
                System.out.println("so easy....");
            }}, new Date(System.currentTimeMillis()+1000), 200);
    }

}
_程序猿滴滴
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通过Java的继承与聚合两种形式实现静态代理
xiejiejian的博客
04-14 783
运用场景：当需要调用到某个方法，而又需要在该方法执行之前或之后再执行其他的逻辑时，就可以用到代理的技术。分类：代理分为静态代理和动态代理两种。可以通过两种方式来实现静态代理，一种是继承的方式，另一种是聚合的方式。代码演示：假设汽车有run（行驶）和stop（停止）两个功能，通过一个CarInterface接口来表示package cn.jie.util; public interface Car...
【Java】代理模式（Proxy模式）详解
热门推荐
Passer_hua的博客
01-21 2万+
Java代理模式详解
7、多线程（静态代理模式（实现Runnable接口来创建线程））
分享java学习路上的一些笔记，不足之处多多见谅。
10-14 340
【代码】7、多线程（静态代理模式（实现Runnable接口来创建线程））例子：我们前面学习的实现Runnable接口来创建线程的方式就用了代理模式（主线程内的创建时候）也就是Thread（race，“兔子”）.start。 这里面Thread（里面实现了Runnable接口）和这个race都实现了这个Runnable这个接口。所以Thread就是这个代理，里面的这个race就是目标对象（他在专注于他的重写run方法里面，他是无法.start开启线程的）所以就用Thread这个代理去.start（）开启
多线程-静态代理
qq_33879443的博客
08-06 183
1
多线程05 静态代理模式
m0_56392935的博客
11-13 107
对应于代理模式中即：客户类、代理类 、委托类（被代理类）。为某一个对象（委托类）提供一个代理（代理类），用来控制对这个对象的访问。new Thread(()-> System.out.println("爱")).start();System.out.println("落花要结婚了");//代理对象可以做很多真实对象做不了的事情。//真实对象和代理对象都要实现同一个接口。//真实对象专注做自己的事情。//代理谁-->真实目标角色。//代理对象要代理真实角色。//代理角色，帮助你结婚。//真实角色，你去结婚。
Java-JUC-多线程 进阶
07-05
Java 中的线程可以通过继承 Thread 类或实现 Runnable 接口来创建。 Lock 锁 锁（Lock）是 Java 中的一种同步机制，用于保护共享资源免受多个线程的并发访问。Lock 锁可以分为独占锁（Exclusive Lock）和共享锁...
objective-c面试大全
10-31
1. **对象间的交互**：Objective-C中，对象间的通信主要通过消息传递机制实现，包括代理模式（Delegate）、观察者模式（Observer）、Blocks以及App Delegate。代理允许一个对象向另一个对象发送通知，观察者模式用于...
求职宝典-Java 基础面试题
04-02
动态代理是Java设计模式中的一个重要概念，它分为静态代理和动态代理。静态代理是在编写代码阶段就已知代理类，而动态代理则在程序运行时才创建。动态代理通常是基于反射实现的，可以方便地对多个类的方法进行统一...
设计模式入门之一：深入单例模式
09-09
结构型模式如组合、门面、代理、适配器、装饰者、桥接、享元模式则关注于如何组织和组合类或对象。行为型模式包括迭代器、观察者、模板方法、命令、状态、策略、责任链、中介者、访问者、解释器和备忘录，它们主要...
java面试宝典梳理大纲最终-赵学浦.docx
07-13
以上只是Java面试中的一部分常见问题，全面准备还需要深入学习异常处理、IO流、多线程、网络编程、设计模式等更多主题。在面试过程中，能够结合实际项目经验来阐述这些概念会更有利于展示自己的技能和经验。
多线程_静态代理
Mudrock__的博客
08-08 102
代理对象可以做到真实对象做不到的事。真实对象和代理对象实现同一个接口。真实对象专注于自身的事。线程的底层实现原理：静态代理。代理对象代理真实对象。
静态代理通过继承实现静态代理
sinat_36695865的博客
02-02 511
package com.jason.staticProxy; /** * @author jason * @Description:定义一个汽车接口,里面包含汽车行驶的方法 * @date 2018/2/2 */ public interface Car { //定义一个汽车行驶的方法 public void run() throws Exception; } p
Java多线程之静态代理
qq_38723455的博客
01-01 148
本篇学习的是多线程的静态代理，以结婚为举例，婚庆公司为代理角色，自己为真是角色。 package lesson04; public class StaticProxy { public static void main(String[] args) { new WeddingCompony(new You()).happyMarry(); new Thread(()-> System.out.println("111")).start(); .
Java多线程2--Runnable+静态代理实现线程
F的博客
07-29 663
创建线程的另一种方法是声明实现 Runnable 接口的类。该类实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动 先创建一个Programmer类继承Runnable，重写Run方法 /* * 使用Runnable创建线程 * 1.类实现Runnable接口+重写run() --->真实角色类 * 2.启动多线程 使用静态代理 * ...
多线程03--静态代理模式
liulianglin的专栏
03-20 261
1.引言 在学习多线程的过程中，有必要学习下静态代理模式，为啥呢？在《多线程01--线程》中，我们提到创建线程的几种方式，其中之一就是实现Runnable接口，这时其实就使用到了我们的静态代理模式。当然现实生活中，也有很多存在代理的场景例如房产中介、海淘代购等等，都扮演着代理者的角色。 2.实现 静态代理的实现一般可分为如下几个环节： 存在或定义一个主题接口Subject（包含一个业务方法：如卖房子）； 创建代理类，实现主题接口Subject； 创建真实对象，继承主题接口Subject，实现业
静态代理模式来理解Lambda
Tokisaki_Kurumi的博客
09-03 150
//静态代理模式总结： //真实对象和代理对象都要事先同一个接口 //代理对象要代理真实角色 //好处： //代理对象可以做很多真实对象做不了的事情 //真实对象专注做自己的事情 public class StaticProxy { public static void main(String[] args) { WeddingCompony weddingCompony = new WeddingCompony(new You()); weddi
静态代理
qq_43228581的博客
05-30 107
package com.adrian.demo01; //好处： //代理对象可以做很多真实对象做不了的事情 //真实对象专注做自己的事情 public class StaticProxy { public static void main(String[] args) { You you = new You();//你要结婚了 WeddingCompany weddingCompany = new WeddingCompany(you);//把"
多线程-静态代理的方式 - 实现Runnable接口
makemeasmile的博客
02-18 539
在看这个小列子之前   建议大家 最好 先理解一下 静态代理的概念. http://blog.csdn.net/makemeasmile/article/details/55667574 其实我们的多线程 以实现 Runnable 接口的形式 这种方式  就是采用了我们的 静态代理模式 启用多线程步奏： 1）、真实角色  -  这个角色 就是你要去做的事情 2）、代理角色
静态代理模式(Static Proxy)解析
koushr的博客
08-07 1403
要使用被代理类对象的方法时，只需简单的实例化代理类对象，并向上转型为接口(面向接口编程)，此时调用此代理类对象的方法就相当于调用被代理类的方法。        当客户端代码需要调用某个对象时，客户端实际上不关心是否准确得到该对象，而是只要一个能提供对应功能的对象即可，这时我们可以为该对象提供一个代理对象，由代理对象控制对源对象的引用。 常见静态代理模式：一个接口，两个实现类，分别为被代理类和代
通过类继承，实现一个线程类
最新发布
05-21
下面是一个简单的线程类实现： ```python import threading class MyThread(threading.Thread): def __init__(self, thread_id, name): threading.Thread.__init__(self) self.thread_id = thread_id self....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值