精华内容
参与话题
问答
  • 佛洛依德冰山原理

    千次阅读 2017-08-16 14:37:55
    冰山理论:是萨提亚家庭治疗中的重要理论,实际上是一个隐喻,它指一个人的“自我”就像一座冰山一样,我们能看到的只是表面很少的一部分——行为,而更大一部分的内在世界却藏在更深层次,不为人所见,恰如冰山。...

    冰山理论:是萨提亚家庭治疗中的重要理论,实际上是一个隐喻,它指一个人的“自我”就像一座冰山一样,我们能看到的只是表面很少的一部分——行为,而更大一部分的内在世界却藏在更深层次,不为人所见,恰如冰山。包括行为、应对方式、感受、观点、期待、渴望、自我七个层次。
    这里写图片描述
    这和我们的记忆相似,当意识是我们劳劳记住的东西,而前意识是我们记住的比较朦胧的东西,无意识虽然在我们脑子当中,但是我们无法直接去意识到。所以说,当我们记忆知识的时候,一定要把线索记住,也就是把线索当成我们的意识,然后让这些牢牢记住的东西按照线索就可以把前意识或者更深的潜意识的东西顺着线索挖掘出来。而记忆的方法和精髓就在于“理解”。
    当你理解的越多,需要记住的就越少!永远记住这句话,将会成为你奋斗的目标。

    展开全文
  • 曾经有一道题,已知:  int a, b;  并已赋值,值的唯一限制是int.MinValue  例如 a = 2147483647, b = 2147000000  又或 a = -2147483600, b = -2147483640  又或 a = 2000000
    
    

    
     曾经有一道题,已知:  
      int   a,   b;  
      并已赋值,值的唯一限制是int.MinValue<=a,b<=int.MaxValue,所有极端情况均有可能  
      例如   a   =   2147483647,   b   =   2147000000  
      又或   a   =   -2147483600,   b   =   -2147483640  
      又或   a   =   2000000000,   b   =   -2000000000  
      当然也包括   a   =   0,   b   =   0   (-_-)  
       
      现在要将a,b的值交换  
       
      没有任何导入的命名空间(即如果你要用类,必须从System开始写起)  
      没有任何辅助的方法(即如果你要辅助方法,你要自己写)  
      除了a和b没有其它已经声明的字段或参数或局部变量,  
       
      并且不能再声明任何变量!  
       
      求最短的、编译可以通过的、所有情况下都能达到目的的   C#   代码   
        
       用来测试的代码:  
      class   Program  
      {  
              static   void   Main()  
              {  
                      int   a   =   1234567890,   b   =   987654321;  
                      /**************************\  
                        *   将你的答案填入下面两个斜杠内   *  
                        *//*  
                        *   将你的答案填入上面两个斜杠内   *  
                      \**************************/  
                      System.Console.WriteLine("a={0},b={1}",   a,   b);  
                      System.Console.ReadLine();  
              }  
      }  



    正确的解法是:
    a   =   b   +   (   b   =   a   )   *   0

    编译原理:
    首先编译器根据运算符优先级,先找到这个里面最优先的运算符*,确定结合顺序如下:
    a   =   (   b   +   (   (   b   =   a   )   *   0   )   )

    接下来,根据C#规范,会从左至右计算每个子表达式的值,第一个子表达式b,值为当前b值,记为b &apos;,第二个子表达式b   =   a,值为当前a值,记为a &apos;,最后一个表达式0,值为0。

    接下来,根据刚才确定的顺序,依次进行计算。
    b   =   a已经运算完毕,值为a &apos;,这时进行乘法运算,然后进行加法运算,然而C#的编译器意识到这个加法是没有意义的,故而优化掉,所以,整个表达式被优化为:
    a   =   b &apos;

    加上刚才计算子表达式的值时计算的b   =   a。

    故而C#的编译器做出了最简的IL代码。
    展开全文
  • 实现AIR应用自动更新的大致原理,以下是类文件和调用示例: package Neo { import flash.display.*; import flash.filesystem.*; import flash.desktop.Updater; import flash.events.*; i...
    实现AIR应用自动更新的大致原理,以下是类文件和调用示例:

    package Neo
    {
    import flash.display.*;
    import flash.filesystem.*;
    import flash.desktop.Updater;
    import flash.events.*;
    import flash.net.*;
    import flash.xml.*;
    import flash.text.TextField;
    import flash.utils.ByteArray;
    import flash.events.IOErrorEvent;

    public class AIRUpdater extends Sprite
    {
    public var version:String;
    public var updataURL:String;

    private var updataRequest:URLRequest;
    private var updataLoader=new URLLoader();
    private var newVersion:String;
    private var airURLString:String;
    private var urlReq:URLRequest;
    private var urlStream:URLStream;
    private var fileData:ByteArray;
    private var baseSprite:Sprite=new Sprite();
    private var tipText:TextField=new TextField();
    private var btYes:Sprite=new Sprite();
    private var btYesText:TextField=new TextField();
    private var btNo:Sprite=new Sprite();
    private var btNoText:TextField=new TextField();

    public function AIRUpdater():void
    {
    baseSprite.graphics.beginFill(0×000000,0.5);
    baseSprite.graphics.lineStyle(8,0×000000,0.1);
    baseSprite.graphics.drawRoundRect(0,0,360,160,10);
    baseSprite.graphics.endFill();
    /*add base*/
    tipText.width=300;
    tipText.height=30;
    tipText.x=tipText.y=30;
    tipText.autoSize=”center”;
    tipText.textColor=0xFFFFFF;
    tipText.text=”You must update your AIR Application now,ok?”;
    baseSprite.addChild(tipText);
    /*add button*/
    btYes.graphics.beginFill(0×000000,0.5);
    btYes.graphics.lineStyle(1,0×000000,0.1);
    btYes.graphics.drawRoundRect(0,0,36,20,10);
    btYes.graphics.endFill();
    btYesText.width=36;
    btYesText.text=”Yes”;
    btYesText.autoSize=”center”;
    btYesText.textColor=0xFFFFFF;
    btYes.addChild(btYesText);
    btNo.graphics.beginFill(0×000000,0.5);
    btNo.graphics.lineStyle(1,0×000000,0.1);
    btNo.graphics.drawRoundRect(0,0,36,20,10);
    btNo.graphics.endFill();
    btNoText.width=36;
    btNoText.text=”No”;
    btNoText.autoSize=”center”;
    btNoText.textColor=0xFFFFFF;
    btNoText.selectable=btYesText.selectable=false;
    btNo.addChild(btNoText);
    btYes.x=100;
    btYes.y=100;
    btNo.x=210;
    btNo.y=100;
    btYes.buttonMode=btNo.buttonMode=true;
    baseSprite.addChild(btYes);
    baseSprite.addChild(btNo);
    }
    /*Function For Update Application*/
    public function updateMyApp():void
    {
    updataRequest=new URLRequest(updataURL);
    updataLoader.load(updataRequest);
    updataLoader.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
    updataLoader.addEventListener(Event.COMPLETE,loaderCompleteHandler);
    }
    /*loaderCompleteHandler*/
    private function loaderCompleteHandler(event:Event):void
    {
    try {
    var result:XML=new XML(updataLoader.data);
    if (version != result.version)
    {
    newVersion=result.version;
    airURLString=result.lastpublic;
    trace(”马上更新到最新版吗?” + “有新的更新”);
    addChild(baseSprite);
    baseSprite.x=(stage.stageWidth-baseSprite.width)/2;
    baseSprite.y=(stage.stageHeight-baseSprite.height)/2;
    btYes.addEventListener(MouseEvent.CLICK,updateBtHandler);
    btNo.addEventListener(MouseEvent.CLICK,removeBtHandler);
    }
    } catch (e:TypeError) {
    trace(”Updata Application Error:Could not parse the XML file.”);
    }
    }
    /*errorHandler*/
    private function errorHandler(e:IOErrorEvent):void
    {
    trace(”Updata Application Error:Had problem loading the XML File.”);
    }
    private function updateBtHandler(event:MouseEvent):void
    {
    urlReq=new URLRequest(airURLString);
    urlStream=new URLStream ;
    fileData=new ByteArray ;
    urlStream.addEventListener(Event.COMPLETE,loaded);
    urlStream.load(urlReq);
    }
    private function removeBtHandler(event:MouseEvent):void
    {
    removeChild(baseSprite);
    }
    private function loaded(event:Event):void
    {
    urlStream.readBytes(fileData,0,urlStream.bytesAvailable);
    writeAirFile();
    }
    private function writeAirFile():void
    {
    var file:File=File.desktopDirectory.resolvePath(”lastPublish.air”);
    var fileStream:FileStream=new FileStream ;
    fileStream.addEventListener(Event.CLOSE,fileClosed);
    fileStream.openAsync(file,FileMode.WRITE);
    fileStream.writeBytes(fileData,0,fileData.length);
    fileStream.close();
    }
    private function fileClosed(event:Event):void
    {
    trace(”The AIR file is written.”);
    var updater:Updater=new Updater ;
    var airFile:File=File.desktopDirectory.resolvePath(”lastPublish.air”);
    updater.update(airFile,newVersion);
    }
    }
    }

    调用示例:
    import flash.display.*;
    import flash.filesystem.*;
    import flash.desktop.Updater;
    import flash.events.*;
    import flash.net.*;
    import flash.xml.*;
    import flash.utils.ByteArray;
    import flash.events.IOErrorEvent;
    import Neo.AIRUpdater;

    var aupSample:AIRUpdater=new AIRUpdater();
    aupSample.version=”alpha1″;
    aupSample.updataURL=”http://localhost/testUpdate/version.xml”;
    aupSample.updateMyApp();
    addChild(aupSample);
    用于判断版本的XML结构示意:
    <?xml version=”1.0″ encoding=”utf-8″?>
    <example>
    <version>alpha2</version>
    <lastpublic>http://localhost/testUpdate/main.air</lastpublic>
    </example>
    展开全文
  • Java多线程之冰山一角

    2019-09-26 03:09:02
    多线程原理 线程类: //继承线程类,重写run方法 public class MyThread extends Thread{ public void run(){ for (int i = 0; i < 100; i++) { System.out.println("i="+i); } ...

    一.   多线程原理

    线程类:

    //继承线程类,重写run方法

    public class MyThread extends Thread{

        public void run(){

            for (int i = 0; i < 100; i++) {

                System.out.println("i="+i);

            }

        }

    }

    测试类:

    //启动线程

    public class Demo01 {

         //主线程

        public static void main(String [] args){

            //创建子类对象

            MyThread myThread=new MyThread();

            //调用父类的start方法,启动多线程

            myThread.start();

            for (int k = 0; k < 100; k++) {

                System.out.println("k="+k);

            }

        }

    }

    多个线程运行原理:

    1.当主线程启动一个独立了的线程后,这个独立的线程就会与主线程“同时”运行;

    2.对于单颗,单核CUP来说,在某一个时间点上,CPU中只有一个线程在运行(由操作系统分配时间片,时间片用完后切换其他的线程)一段时间。

    二.  1.     创建线程的方式一:继承Thread类及其常用方法

    步骤:

    (1)  自定义线程类,继承Thread

    (2)  重写Thradrun()方法(线程中要完成的功能就放在run()方法中);

    3)启动线程

    a.创建线程类对象

    b.调用对象的start()方法

    示例代码:同上

    2.  使用线程时的注意事项:

    (1)  一个线程类可以创建多个线程对象,每个线程对象都可以单独启动;

    (2)  一个线程对象只能启动一次(即调用一次start()方法);

    (3)  在线程类中,重写的时run() 方法,但是在测试了中启动线程调用的是start() 方法。

    3.  Thread类中的常用方法

    1public String getName()   获取线程名称

           注:每个线程都有一个默认的线程名称:Thread—索引值

    2public  void  setName ()          设置线程名称

    3public  static  currentThread ()    获取当前线程对象

    4public  static  sleep()              使线程休眠指定的毫秒数

    示例代码:

    线程类:

    public class MyThread extends Thread{

        public void run(){

            for (int i = 0; i < 100; i++) {

                System.out.println(this.getName()+"  i="+i);

                try {

                    Thread.sleep(1000);//休眠指定的毫秒数

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

    }

           测试类:

    public class Demo01 {

        public static void main(String [] args){

            //创建子类对象

            MyThread myThread=new MyThread();

            myThread.setName("独立线程");//设置线程名称

            Thread.currentThread().setName("主线程");//设置线程名称

            //调用父类的start方法,启动多线程

            myThread.start();

            for (int k = 0; k < 100; k++) {

                System.out.println(Thread.currentThread().getName()+"  k="+k);//获取当前线程对象

                try {

                    Thread.sleep(1000);//休眠指定的毫秒数

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

    }

    三.  创建线程的方式二:实现Runnable接口

    1.  步骤

    (1)  自定义类实现Runnable接口;

    (2)  重写run() 方法;

    (3)  启动线程

    a.  创建一个自定义对象

    b.  创建一个Thread对象,并将自定义对象作为参数传给Runnable的构造方法;

    c.  调用方Thread对象的start()方法启动线程。

     

     

    线程类:

    public class MyRunnable implements Runnable {

        @Override

        //重写Runnable中的run() 方法

        public void run() {

            for (int i = 0; i < 100; i++) {

                System.out.println(Thread.currentThread().getName()+"   i="+i);

                //休眠指定的毫秒数

                try {

                    Thread.sleep(1);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

    }

     

    测试类:

    public class Demo {

        public static void main(String[] args) {

            //创建自定义类对象

            MyRunnable myRunnable=new MyRunnable();

            //创建Thread对象,并将自定义对象作为参数传给Thread的构造方法

            Thread thread=new Thread(myRunnable);//调用Thread对象的start()方法启动线程

            //为线程设置名称

            thread.setName("独立线程");

            Thread.currentThread().setName("主线程");

            thread.start();

            for (int k = 0; k < 100; k++) {

                System.out.println(Thread.currentThread().getName()+"   k="+k);

                //休眠指定的毫秒数

                try {

                    Thread.sleep(1);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

    }

     

    四.  两种创建线程的区别

    1.  Thread 通过继承方式实现多线程,这就限制了子类的继承关系;

    2.  Runnable 通过实现接口的方式实现多线程,不会对实现类造成限制,较为灵活。

    五.  匿名内部类的方式实现线程

    1.  使用Thread匿名子类

    public class ThreadDemo {

        public static void main(String[] args) {

            new Thread(){

                public void run(){

                    for (int i = 0; i < 100; i++) {

                        System.out.println("i="+i);

                    }

                }

            }.start();

            for (int k = 0; k < 100; k++) {

                System.out.println("k="+k);

            }

        }

    }

    2.  使用Runnable

    public class RunnableDemo {

        public static void main(String[] args) {

            new Thread(new Runnable() {

                @Override

                public void run() {

                    for (int i = 0; i < 100; i++) {

                        System.out.println("i=" + i);

                    }

                }

            }).start();

            for (int k = 0; k < 100; k++) {

                System.out.println("k="+k);

            }

        }

    }

    六.  多线程的安全问题

    1.  不安全的火车票售票机制

    线程类:

    public class Tickets implements Runnable  {

        private int tickets=100;

        @Override

        public void run() {

           while(true){

               try {

                   Thread.sleep(1);

               } catch (InterruptedException e) {

                   e.printStackTrace();

               }

               if(tickets>0){

                   System.out.println("给线程"+Thread.currentThread().getName()+"取走一张票"+tickets);

                   tickets--;

               }else{

                   System.out.println("没票了...");

                   break;

               }

           }

        }

    }

     

    测试类:

    public class Demo {

        public static void main(String[] args) {

            //创建线程类对象

            Tickets tickets=new Tickets();//休眠一毫秒,可以更加明显

            //创建Thread对象,将Runnable对象作为参数传给Thread的构造方法,通过Thread对象调用方法

            Thread t1=new Thread(tickets);

            Thread t2=new Thread(tickets);

            Thread t3=new Thread(tickets);

            //设置线程名称

            t1.setName("窗口1");

            t2.setName("窗口2");

            t3.setName("窗口3");

            //启动线程

            t1.start();

            t2.start();

            t3.start();

        }

    }

    此时会出现一张票被多个人买走的情况,非常的不安全。

    七.  线程同步解决线程安全问题

    1.  使用同步代码块解决多线程安全问题

    public class Tickets implements Runnable  {

        private int tickets=100;

        Object obj=new Object();

        @Override

        public void run() {

           while(true) {

               try {

                   Thread.sleep(1);

               } catch (InterruptedException e) {

                   e.printStackTrace();

               }

               synchronized (obj) {

                   if (tickets > 0) {

                       System.out.println("给线程" + Thread.currentThread().getName() + "取走一张票" + tickets);

                       tickets--;

                   } else {

                       System.out.println("没票了...");

                       break;

                   }

               }

           }

        }

    }

    //测试类同上

     

    2.  使用同步方法解决多线程安全问题

    public class Tickets implements Runnable {

        //Object obj=new Object();

        int tickets=100;

        @Override

        public void run() {

            while(true){

                getTickets();

                try {

                    Thread.sleep(2);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

        public synchronized  void getTickets() {

           if(tickets>0){

               System.out.println("线程"+Thread.currentThread().getName()+"取走了一张票"+tickets);

               tickets--;

           }else {

               System.out.println("没票了....");

               System.exit(0);

           }

        }

    }

     

     

    说明:同步方法可以是普通方法,也可以是静态方法。只要这个方法被多个线程同时访问,但是程序值希望只有一个线程执行全部方法体后,才允许其他线程访问,这种情况下可以将方法声明为同步方法,这样可以保证数据的安全性。

    https://www.cnblogs.com/LLLaoJia/

    转载于:https://www.cnblogs.com/LLLaoJia/p/9502892.html

    展开全文
  • 多线程原理 线程类: //继承线程类,重写run方法 public class MyThread extends Thread{ public void run(){ for (int i = 0; i &lt; 100; i++) { System.out.println(“i=”+i...
  • extern "C" 是什么?起什么作用? 它背后它和C++的改名机制有什么关系?它和ELF又有什么鲜为人知的秘密?如果你也有着同样的好奇,戳我,我将带你走进科学。不仅能学习C++,还能顺路了解ELF格式、链接器的工作原理
  • 上篇文章一直追踪到了ForkJoinWorkerThread的pushTask方法,仍然没有办法解释Fork的原理,那么不妨来看看ForkJoinWorkerThread的run方法: public void run() { Throwable exception = null; try { // 初始化...
  • 曾经有一道题,已知: int a, b; 并已赋值,值的唯一限制是int.MinValue<=a,b<=int.MaxValue,所有极端情况均有可能 例如 a = 2147483647, b = 2147000000 ... 又或 a = -2147483600, b = -214748...
  • java8 Stream之原理

    2019-06-01 14:40:00
    Stream java8的Stream很重要,spring-reactor里面用到reactor-core,而java8的stream... 先看一下它的强大,这里只是冰山一角: 从List<Student> 列表中取出name,将name组成一个List。 老代码 List<Str...
  • 上篇文章一直追踪到了ForkJoinWorkerThread的pushTask方法,仍然没有办法解释Fork的原理,那么不妨来看看ForkJoinWorkerThread的run方法: public void run() { Throwable exception = null; try { // ...
  • 计算机CPU工作原理及汇编语言简介

    千次阅读 2019-12-25 21:46:22
    然而,无论我们怎么设计电路来制作CPU,它永远只是冰山一角的一个小小冰点, 离Intel或AMD的商用CPU有太远太远的距离。我们不可能也没必要画出那么复杂的CPU(几十亿个晶体管器件)。 因此,我们需要从底层复杂的...
  • 其实在写这篇文章的时候心情还是蛮复杂的,本来以为自己 对SpringBoot自动配置的原理已经理解的差不多了吧。 自己就想把这部分写的详细一些,期间查阅了大量的博客和文章,也写了小五千字。 后来想了解一下run();...
  • 在《自定义控件其实很简单》系列的前半部分中我们用了整整六节近两万字两百多张配图讲了Android图形的绘制,虽然篇幅很巨大但仍然只是图形绘制的冰山一角,旨在领大家入门,至于修行成果就看各位的了……那么这个些...
  • 在《自定义控件其实很简单》系列的前半部分中我们用了整整六节近两万字两百多张配图讲了Android图形的绘制,虽然篇幅很巨大但仍然只是图形绘制的冰山一角,旨在领大家入门,至于修行成果就看各位的了……那么这个些...
  • 但是程序通过了编译检查并不表示错误已经不存在了,在“错误”的大家庭里,“语法错误”的地位只能算是冰山一角。级别高的错误通常隐藏得很深,不容易发现。  根据经验,不少难以察觉的程序错误是由于变量没有被...
  • Flex tween 小原理

    2011-03-26 01:15:16
    本文来源于 冰山上的播客 http://xinsync.xju.edu.cn , 原文地址:http://xinsync.xju.edu.cn/index.php/archives/1304 在Flex里面不像在Flash里面随意制作动画了,Flex更趋向于应用程序,而不是动画制作了,...
  • 在《自定义控件其实很简单》系列的前半部分中我们用了整整六节近两万字两百多张配图讲了Android图形的绘制,虽然篇幅很巨大但仍然只是图形绘制的冰山一角,旨在领大家入门,至于修行成果就看各位的了……那么这个些...
  • 构造函数与析构函数的原理 作为比C更先进的语言,C#提供了更好的机制来增强程序的安全性。C#编译器具有严格的类型安全检查功能,它几乎能找出程序中所有的语法问题,这的确帮了程序员的大忙。但是程序通过了编译...
  • 引言:从整个软件的性能来说,资源类性能就像是撑起冰山一角的下面的冰层。构成这部分的,是传统部分的磁盘、CPU、内存和网络以及因为移动网络而显得特别重要的电池(耗电)。本文我们将向您着重介绍磁盘部分。 ...
  • Android代码-DriodDeveloper

    2019-08-08 07:40:06
    [[已推送]开发直播app中要了解的原理] [[已推送]优化工作的冰山一角,app瘦身] [[已推送]连麦互动技术及其连麦调研] [[已推送]音视频开发中常见基础问题总结] [[已推送]FFmpeg开发(一)常用处理视频命令] [[已推送]...
  • 后台篇_20200521.rar

    2020-05-21 00:20:12
    术探究》,带领我们探究了技术底层的实现原理;《美团点评 Kubernetes 集群管理实 践》、《美团集群调度系统 HULK 技术演进》,展现了对成千上万台机器如何进行管理 的艺术。 「泰山不让土壤,故能成其大;河海不择...
  • 你不知道的Java黑魔法

    2020-04-15 22:04:05
    现在的编程语言越来越复杂,尽管有大量的文档和书籍,这些学习资料仍然只能描述编程语言的冰山一角。而这些编程语言中的很多功能,可能被永远隐藏在黑暗角落。本文将为你解释其中5个Java中隐藏的秘密,可以称其为...
  • 素数看似简单、实则神奇,且奥秘无穷,数百年来,引无数数学英才为其着迷,毕生追求,并衍生出众多命题和分支,闻名遐迩的的哥德巴赫猜想和费马数,只是素数研究诸多命题沧海一粟、冰山一角。 而要研究素数规律,...
  • 简述“冰山模型”。 通用模型设计步骤。 简述“学习地图”原理和步骤。 人员测评与选拔主要方法。 1、面试法; 2、物理测试; 3、操作能力测试; 4、心里测试法; 5、评价中心技术; ... ... ... 关键词:...
  • 素数看似简单、实则神奇,且奥秘无穷,数百年来,引无数数学英才为其着迷,毕生追求,并衍生出众多命题和分支,闻名遐迩的的哥德巴赫猜想和费马数,只是素数研究诸多命题沧海一粟、冰山一角。 而要研究素数规律,...
  • 奇奇SEO优化软件8.1

    2013-05-22 10:56:43
    当然,众多的功能,对绝大多数网友可能只使用了冰山一角,更多的潜在的用武之地,待你挖掘和琢磨! 奇奇SEO优化软件特点 1、简单易用 使用简单,操作方便,自动升级,针对个人网站永久免费。 2、高度安全 ...
  • 书中讲解了大量在开发操作系统中需注意的细节问题,这些细节不仅能使读者更深刻地认识操作系统的核心原理,而且使整个开发过程少走弯路。本书分上下两篇,共11章。其中每一章都以前一章的工作成果为基础,实现一项新...

空空如也

1 2 3 4 5
收藏数 83
精华内容 33
热门标签
关键字:

冰山原理