精华内容
下载资源
问答
  • 关于遗憾感言说说朋友圈80句 当生活有了遗憾,就会脑子里一直出现。你生活有遗憾吗? 关于遗憾感言 1. 我并不失落,我也没有受伤,没有生气,我只是有点累了,我厌倦了付出太多,回报太少。 2. 终于明白,...
  • 运行时,如果有其他的线程过来抢占该线程的时间片,导致线程丢失时间片,旁边等待的过程称为阻塞BLOCKED 当运行的线程调用到了wait方法,线程就会进入一个一直等待的状态waiting 当运行的线程调用了sleep方法...

    线程的六个状态

    查看jdk可以发现如下的定义

     

     

    当线程刚被创建出来,还没有调用start方法的时候,这个时候线程处于NEW状态,当使用了start方法,线程就进入了RUNNABLE状态

    线程最终的归宿都是死亡,停止状态TERMINATED

    在运行时,如果有其他的线程过来抢占该线程的时间片,导致线程丢失时间片,在旁边等待的过程称为阻塞BLOCKED

    当运行的线程调用到了wait方法,线程就会进入一个一直等待的状态waiting

    当运行的线程调用了sleep方法,就会进入一个TIMED_WAITING等待状态

     

    创建线程的第三种方式Callable

     

    Callable和Runnable接口类似,Callable接口不同于Runnable的是它需要返回值

    我们通常认为创建线程的方式只有两种,但是创建线程还有第三种方法,使用Callable接口。我们继承Thread和实现Runnable接口方式的线程方法,创建的线程和主线程之间可以理解为是一种并发的关系,同时在执行。但是Callable接口不一样,它可以是主线程分配的任务,也可以是和主线程并发执行。使用Callable实现的线程,可以在主线程执行之前执行,等到Callable线程执行完成之后,然后主线程才执行

     

    使用Callable接口的第二步使用到了FutureTask对象,我们来看看这个类

     

    打印的效果:

     

     

    展开全文
  • 也来说说JAVA NIO

    2017-05-10 10:07:04
    在读取网络端流或者文件流时候,假设用readline()函数读取流中数据,如果流中没有数据或者数据没有结束标识,那么会一直执行读取动作,流中没有数据就一直等待数,有数据就读完为止,在等待数据时候线程也会...

    为什么要NIO,因为为传统IO(即BIO)会造成线程阻塞。

    传统IO是怎么阻塞的呢,在读取网络端的流或者文件流的时候,假设用readline()函数读取流中的数据,如果流中没有数据或者数据没有结束标识,那么会一直执行读取动作,流中没有数据就一直等待数,有数据就读完为止,在等待数据的时候线程也会被阻塞的【就是说程序一直会卡在readline()这里进行不下去】,那么单线程只能很好的处理一个网络IO,因为在连接一个客户端之后执行readline(),如果客户端不输入数据,那么服务器端会一直停留在readline()这里,所以当其它客户端建立连接之后,客户端不能同时去读取流中的数据。当然如果对每一个客户端开启一个新线程来处理,即每个线程都对应一个readline(),那么就可以解决同时不能处理多个客户端数据的问题,但是这样就导致了服务器性能的下降,有多少一个连接就要启动多少个线程,如果连接非常多,线程栈内存的开销,线程切换以及CPU处理能力消耗都会带来服务器的性能下降,着也是为什么要NIO的原因,NIO就是为了解决这个问题的。

    Note: 初学者有一点要分清,不管是IO还是NIO,有多少个客户端请求就要建立多少个连接(所谓建立连接只不过就是客户端在内存中存储服务器端的信息比如IP端口,服务器端在内存中存储客户端的数据,这就叫建立连接,不是现实中一样用一个绳子连起来),在这方面它们是没有区别的,区别的是建立连接之后处理客户端和服务端数据传输(数据读写)的区别。

    那么NIO为什么不会阻塞呢,由BIO可知,NIO就是把readline()这一步抽取出来由某个逻辑集中处理,这个逻辑会一直监听所有连接中(这就是和BIO的区别,BIO是readline()一直傻傻的在那里等,但是NIO是有一个单独的逻辑监听所有连接,这样线程就可以抽身出来了)是否用东西可以读取了,如果有就执行读取操作以及之后的逻辑,这个单独用来监听所用连接动作的逻辑就叫Selector,哪个连接把数据从客户端传过来了,服务器可以读取了Selector就会得知,然后就可以处理这些数据了。

    综上所述,NIO和BIO的区别说白了就是在数据准备的时候采取不同的操作,一个客户端的连接建立之后,BIO只是在那里傻傻的等待客户端的输入,这就导致了客户端线程的阻塞,而NIO用一个专门的逻辑来探测所有客户端是否输入了数据,不用傻傻的一直等待某一个客户端的数据了,就不会导致占着茅坑不拉屎的局面,如果是BIO的话,等待的那个客户端一直不输入数据,如果另外的客户端连接要输入数据,但是因为线程被等待的那个阻塞了,导致输入的数据处理不了。




    展开全文
  •  自己第一次参加校招,以前都只是电话面试过,第一次看到校招过程,很多人在等候厅等待自己面试结果,有欢喜有悲伤,这也就是人生吧,由于自己是霸面,投放了自己简历以后就一直在等待,要等正式面试人结束...
     故事开始

      由于错过了美团的校招投放简历,没参加美团笔试,只能去参加霸面,给自己增加一些经验,确实这次收获很大,让自己学到很多东西。

      自己第一次参加校招,以前都只是电话面试过,第一次看到校招过程,很多人在等候厅等待自己的面试结果,有欢喜有悲伤,这也就是人生吧,由于自己是霸面,投放了自己的简历以后就一直在等待,要等正式面试的人结束以后才能有机会让我们去面试,等待的过程还是比较辛苦的。

      然后开始了第一面,第一面全程比较轻松,面试官也比较随和,在面试过程中没有一点紧张的感觉,问的问题也比较基础,大多是JS和CSS基础,也有一些排序。

      等了一会就开始第二面,第二面开始面试官就让我根据题写了3个程序,用JS写的,随机打乱一个数组,逆序输出字符串,根据经验也写的比较快,然后问了我http请求的整个过程,包括参数还有返回,这是比较模糊的,因为之前总是把目光集中在几种响应状态,什么304,200,404,500。还是自己看东西不太注重细节,总想着如何应付面试,这是自己的错,应该改正,不论一项流行的技术,都有他存在的必要,理解他的底层实现是必须面对的,以后我也不会再逃避。

     故事转变

       就这样还比较轻松的结束了第二面,到第三面的时候,我也觉得可以轻松应付,但实际上确实是自己想太多了,现在回想起来第三面,只能用目瞪口呆来形容,第三面开始,面试官让我做一个简单的自我介绍,然后让我写DOM的增删改查操作,对于原生的DOM操作应该是比较熟悉,但还是会和jquery混合起来,想起一个jquery的操作,然后自己又在想有没有相应的原生操作,多多少少写得差不多,但氛围让我非常紧张,已经开始感觉无措,然后面试官问对于jquery中,$()括号中可以存放些什么东西,自己回答出选择器、dom、function以后实在想不出其他来,我已经感觉到面试官脸上的无奈,也没说其他的,就下一个问题,对于jquery中$$("#id").on("click",function()).attr("title"),这种链式编程用原生JS如何实现,当我看见2个$的时候我已经呆了,根本没见过,还如何用原生js来写,想了一会还是说不知道,然后下一题,知道ecmascript 6中的作用域吗?又蒙了,没听说过ecmascript 6,好吧,下一题,ajax的底层实现,嗯。。这个本来是应该知道的,但实在是已经无力回答,支支吾吾说不下去,好吧,面试官也不想问了,我的问题完了,你有没有想问的,我说能不能问一些基础的,常用的?他看着有点火大,知道new一个对象有几步吗?这个我知道啊,汤姆大叔写得很清楚,三步,1:创建一个新对象,2:把这个对象的__proto__指向构造函数的prototype对象,3:把这个对象当做this传入构造函数中完成初始化,感觉自己没什么不对,面试官说你在哪里看到的?我说博客园里,他说如果我说new一个对象有20步,你相信吗?又蒙了,你难道就没有怀疑过别人的文章?我是看的ecmascript 6标准,你以后多去看标准。嗯,我已经无力反驳了。

     故事总结

        这次面试以后回去,我整个人都没晃过神来,如果不能相信别人的文章,那以后还敢去看博文吗?每次都要怀疑别人写的东西是不是对的,他说的也没错,我是该多去看标准。

        这次面试反响出自己很多的问题,很多东西本来已经找到相关的文章,但由于太长太无趣而没有仔细去研究里面的内容,只把以前别人面试过的东西当做重点,这其实是错误的,身为一个有梦想的程序员,本该踏踏实实去了解底层实现,不该取巧。

       其次呢,jquery的源码应该是我以后的重要目标,让自己深入去学习jquery,了解他的运行过程。

         我以后绝对不允许别人再说我的jquery不好。就以此片文章,谨记。

    转载于:https://www.cnblogs.com/xiaohaoxuezhang/p/4817403.html

    展开全文
  • 如果其他线程尝试进入锁定代码,则它将一直等待(即被阻止),直到该对象被释放。lock 关键字开始处调用 Enter,而结尾处调用 Exit。 ThreadInterruptedException 引发,如果 Interrupt 中断等待输入...

    lock

    首先先上官方Msdn的说法

    lock 关键字可确保当一个线程位于代码的临界区时,另一个线程不会进入该临界区。 如果其他线程尝试进入锁定的代码,则它将一直等待(即被阻止),直到该对象被释放。
    lock 关键字在块的开始处调用 Enter,而在块的结尾处调用 Exit。 ThreadInterruptedException 引发,如果 Interrupt 中断等待输入 lock 语句的线程。
    通常,应避免锁定 public 类型,否则实例将超出代码的控制范围。

    常见的结构 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 违反此准则:
    如果实例可以被公共访问,将出现 lock (this) 问题。
    如果 MyType 可以被公共访问,将出现 lock (typeof (MyType)) 问题。
    由于进程中使用同一字符串的任何其他代码都将共享同一个锁,所以出现 lock("myLock") 问题。
    最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。
    在 lock 语句的正文不能使用 等待 关键字。

    Enter指的是Monitor.Enter(获取指定对象上的排他锁。),Exit指的是Monitor.Exit(释放指定对象上的排他锁。)

    有上面msdn的解释及Exit方法,可以这样猜测“直到该对象被释放”,”该对象“应该是指锁的对象,对象释放了或者对象改变了,其他的线程才可以进入代码临界区(是不是可以这样来理解?)。

    在多线程中,每个线程都有自己的资源,但是代码区是共享的,即每个线程都可以执行相同的函数。这可能带来的问题就是几个线程同时执行一个函数,导致数据的混乱,产生不可预料的结果,因此我们必须避免这种情况的发生。

    打个比方,有这样一个情景,很多公司所在的大厦的厕所的蹲位都是小单间型的,也就是一次只能进去一个人,那么为了避免每次进去一个人,那怎么做呢?不就是一个人进去之后顺手把门锁上么?这样你在里面干啥事,外边的人也只能等待你解放完了,才能进入。而蹲位的资源(蹲位,手纸等)是共享的。

    最常使用的锁是如下格式的代码段:

    private static object objlock = new object();
    lock (objlock )
    {
        //要执行的代码逻辑
    }

    为什么锁的对象是私有的呢?还是以厕所为例子吧,私有就好比,这把锁只有你能访问到,而且最好这把锁不会因为外力而有所改变,别人访问不到,这样才能保证你进去了,别人就进不去了,如果是公有的,就好比你蹲位小单间的锁不是安装在里面而是安装在外边的,别人想不想进就不是你所能控制的了,这样也不安全。

    lock(this)

    通过字面的意思就是锁的当前实例对象。那是否对其他实例对象产生影响?那下面看一个例子:

    复制代码
     1 namespace Wolfy.LockDemo
     2 {
     3     class Program
     4     {
     5         static void Main(string[] args)
     6         {
     7             Test t = new Test();
     8             Test t2 = new Test();
     9             Thread[] threads = new Thread[10];
    10             for (int i = 0; i < threads.Length; i++)
    11             {
    12                 //通过循环创建10个线程。
    13                 threads[i] = new Thread(() =>
    14                 {
    15                     t2.Print();
    16                 });
    17                 //为每个线程设置一个名字
    18                 threads[i].Name = "thread" + i;
    19 
    20             }
    21             //开启创建的十个线程
    22             for (int i = 0; i < threads.Length; i++)
    23             {
    24                 threads[i].Start();
    25             }
    26 
    27             Console.Read();
    28         }
    29     }
    30     class Test
    31     {
    32         public void Print()
    33         {
    34             lock (this)
    35             {
    36                 for (int i = 0; i < 5; i++)
    37                 {
    38                     Console.WriteLine("\t" + Thread.CurrentThread.Name.ToString() + "\t" + i.ToString() + " ");
    39                 }
    40             }
    41         }
    42     }
    43 }
    复制代码

    如果在不加锁的情况下输出如下:

    从上面的输出结果也可以看出,线程出现了争抢的现象,而这并不是我们想要的结果,我们想要的是,每次只有一个线程去执行Print方法。那我们就尝试一下lock(this)

    复制代码
     1     class Test
     2     {
     3         public void Print()
     4         {
     5             lock (this)
     6             {
     7                 for (int i = 0; i < 5; i++)
     8                 {
     9                     Console.WriteLine("\t" + Thread.CurrentThread.Name.ToString() + "\t" + i.ToString() + " ");
    10                 }
    11             }
    12         }
    13     }
    复制代码

    输出结果

    从输出结果,觉得大功告成了,可是现在情况又来了,在项目中的其他的地方,有同事也这样写了这样的代码,又创建了一个Test对象,而且他也知道使用多线程执行耗时的工作,那么就会出现类似下面的代码。

    复制代码
     1 namespace Wolfy.LockDemo
     2 {
     3     class Program
     4     {
     5         static void Main(string[] args)
     6         {
     7             Test t = new Test();
     8             Test t2 = new Test();
     9             t2.Age = 20;
    10             Thread[] threads = new Thread[10];
    11             for (int i = 0; i < threads.Length; i++)
    12             {
    13                 //通过循环创建10个线程。
    14                 threads[i] = new Thread(() =>
    15                 {
    16                     t.Print();
    17                     t2.Print();
    18                 });
    19                 //为每个线程设置一个名字
    20                 threads[i].Name = "thread" + i;
    21 
    22             }
    23 
    24 
    25             //开启创建的十个线程
    26             for (int i = 0; i < threads.Length; i++)
    27             {
    28                 threads[i].Start();
    29             }
    30 
    31             Console.Read();
    32         }
    33     }
    34     class Test
    35     {
    36         public int Age { get; set; }
    37         public void Print()
    38         {
    39             lock (this)
    40             {
    41                 for (int i = 0; i < 5; i++)
    42                 {
    43                     Console.WriteLine("\t" + Thread.CurrentThread.Name.ToString() + "\t" + i.ToString() + " ");
    44                 }
    45             }
    46         }
    47     }
    48 }
    复制代码

    这里为Test加了一个Age属性,为了区别当前创建的对象不是同一个对象。

    输出的结果为

    在输出的结果中已经出现了线程抢占执行的情况了,而不是一个线程执行完另一个线程在执行。

    lock(private obj)

    那么我们现在使用一个全局的私有的对象试一试。

    复制代码
     1 namespace Wolfy.LockDemo
     2 {
     3     class Program
     4     {
     5         private static object objLock = new object();
     6         static void Main(string[] args)
     7         {
     8             Test t = new Test();
     9             Test t2 = new Test();
    10             t2.Age = 20;
    11             Thread[] threads = new Thread[10];
    12             for (int i = 0; i < threads.Length; i++)
    13             {
    14                 //通过循环创建10个线程。
    15                 threads[i] = new Thread(() =>
    16                 {
    17                     lock (objLock)
    18                     {
    19                         t.Print();
    20                         t2.Print();
    21                     }
    22                 });
    23                 //为每个线程设置一个名字
    24                 threads[i].Name = "thread" + i;
    25 
    26             }
    27 
    28 
    29             //开启创建的十个线程
    30             for (int i = 0; i < threads.Length; i++)
    31             {
    32                 threads[i].Start();
    33             }
    34 
    35             Console.Read();
    36         }
    37     }
    38     class Test
    39     {
    40         public int Age { get; set; }
    41         public void Print()
    42         {
    43             for (int i = 0; i < 5; i++)
    44             {
    45                 Console.WriteLine("\t" + Thread.CurrentThread.Name.ToString() + "\t" + i.ToString() + " ");
    46             }
    47         }
    48     }
    49 }
    复制代码

    输出的结果

    从输出的结果也可以看出,有序的,每次进来一个线程执行。

    那通过上面的比较可以有这样的一个结论,lock的结果好不好,还是关键看锁的谁,如果外边能对这个谁进行修改,lock就失去了作用。所以一般情况下,使用静态的并且是只读的对象。

    也就有了类似下面的代码

    1  private static readonly object objLock = new object();

     你可能会说,不对啊,你下面的代码跟上面的代码不一样啊,为什么就得出这样的结论?难道就不能把Object放在test类中么,放在test类中的话,在new Test()的时候,其实放在Test中也是可以的,只要保证objLock在外部是无法修改的就可以。

    上面说的最多的是lock对象,那么它能不能lock值类型?

    答案是否定的,如

    当然lock(null)也是不行的,如图

    虽然编译可以通过,但是运行就会出错。

    lock(string)

    string也是应用类型,从语法上来说是没有错的。

    但是锁定字符串尤其危险,因为字符串被公共语言运行库 (CLR)“暂留”。 这意味着整个程序中任何给定字符串都只有一个实例,就是这同一个对象表示了所有运行的应用程序域的所有线程中的该文本。因此,只要在应用程序进程中的任何位置处具有相同内容的字符串上放置了锁,就将锁定应用程序中该字符串的所有实例。通常,最好避免锁定 public 类型或锁定不受应用程序控制的对象实例。例如,如果该实例可以被公开访问,则 lock(this) 可能会有问题,因为不受控制的代码也可能会锁定该对象。这可能导致死锁,即两个或更多个线程等待释放同一对象。出于同样的原因,锁定公共数据类型(相比于对象)也可能导致问题。而且lock(this)只对当前对象有效,如果多个对象之间就达不到同步的效果。lock(typeof(Class))与锁定字符串一样,范围太广了。

    总结

    关于lock的介绍就到这里,有下面几点需要注意的地方

    1、lock的是引用类型的对象,string类型除外。

    2、lock推荐的做法是使用静态的、只读的、私有的对象。

    3、保证lock的对象在外部无法修改才有意义,如果lock的对象在外部改变了,对其他线程就会畅通无阻,失去了lock的意义。

    参考文章

    http://www.cnblogs.com/jintianhu/archive/2010/11/19/1881494.html

    参考页面:http://qingqingquege.cnblogs.com/p/5933752.html

    转载于:https://www.cnblogs.com/shanshanlaichi/p/6797573.html

    展开全文
  • 说说IO(二)- IO模型

    2015-12-07 14:23:16
    这部分东西在网络编程经常能看到,不过在所有IO处理中都是类似。IO请求两个阶段:等待资源阶段:IO请求一般需要请求特殊资源...在等待数据阶段,IO分为阻塞IO和非阻塞IO。阻塞IO:资源不可用时,IO请求一直...
  • 2020年是不平凡一年,对于考研人儿来说,更是如此,本该2-3月份结束复试,一直稀稀拉拉拖到了6月份,可谓是挣扎在等待煎熬中最辛苦一年啦。幸好,所有等待都是值得。就在刚刚,收到啦拟录取通知啦! ...
  • 通俗说就是:进程在等待被其它进程抢先占用了自己想要资源。而那些其它进程并没有占据它们所有需要资源。也在等待别人占据了它们所需要资源。这样导致都无法运行,因为运行条件不够也不释放自己资源想让...
  • 最近上班有些忙,好久没有更新文章,...导航所有钩子 resolve 完之前一直处于 等待中,等待钩子函数告诉它下一步该怎么做。用next()来指定。 我来给大家举个登陆例子 router.beforeEach(({meta, path}, from, nex
  • 引言上一期我们详细演示了laravel生成命令行参数和选项区别。 然而数据获取方式有很多,...代码时间比如代码中,要求实时获取用名字,并一直等待用户输入:$email laravel Command ask方法就是专门...
  • 最近老遇到通过IDEA工具打开项目中前台页面文件时,工具就一直在刷新这个页面文件,导致文件编写感受很差,下面说说怎么去解决这个问题: 解决方法:清一下IDEA缓存 解决步骤: 1、选择【清无效缓存/重启】...
  • 引言上一期我们详细演示了laravel生成命令行参数和选项区别。 然而数据获取方式有很多,还有一些...代码时间比如代码中,要求实时获取用名字,并一直等待用户输入:$email = $this->ask('What is y...
  • iOS多线程中,使用锁是保证线程访问安全重要手段,而且iOS中给我们提供了很多非常好使用锁,看之前,先说说关于锁一些名词吧。 原子: 同一时间只允许一个线程访问 临界区: 指是一块对公共资源进行...
  • 之前就一直想投字节跳动,对字节跳动整体印象挺好,平等不讲tltle、发展快、成长空间大,现在业务线也比较多,公司平台也上了... 线程池参数,说说定时器的等待队列怎么排序(堆) http 1.1 头部阻塞怎么解决..
  • 首先说说什么是阻塞和非阻塞概念:阻塞操作就是指进程操作设备时,由于不能获取资源或者暂时不能操作设备时,系统就会把进程挂起,被挂起进程会进入休眠状态并且会从调度器运行队列移走,放到等待队列中,...
  •  //处理内容 }   然后再浏览器里面执行,发现这句会一直在执行,关了浏览器,但这个进程仍然是存在,发现只要有输出就一直会存在这个进程,这下麻烦了,因为这个循环里操作了数据库,有不能...
  • 逗乐是有趣的。不过感动是更深刻的。 我认为最感动的两个内容:1、可爱的小德;2、离开WOW的牧师。 小德的经历让我想起了...但是就在等待的同时,很多60级的人因为没法满足他们的FB需要,就转投他会了。始终没有...
  • WaitGroup

    2019-04-01 17:37:00
    WaitGroupgo语言中,用于线程同步,单从字面意思理解,wait等待的意思,group组、团队的意思,WaitGroup就是指等待一组,等待一个系列执行完成后才会继续向下执行。 先说说WaitGroup的用途:它能够一直等到所有的...
  • 线程技术可以让我们程序同时做多件事情...当我们使用ajax向服务端发起请求,由于这个过程很慢,ajax异步模式可以让我们无需一直等待服务端响应,而这个等待结果时间里做其他事情,这个模式线程技术力称...
  • 当应用程序对象上调用了一个需要花费很长时间来执行方法,并且不希望让程序等待方法返回时,就应该使用异步编程,很多情况下采用异步途径往往更有效率。 20、abstract class和interface有什么区别? ...
  • 线程笔记:Future模式

    2016-06-22 21:33:00
     线程技术可以让我们程序同时做多件...当我们使用ajax向服务端发起请求,由于这个过程很慢,ajax异步模式可以让我们无需一直等待服务端响应,而这个等待结果时间里做其他事情,这个模式线程技术力称...
  • 程序会阻塞某一个函数,而不往下执行,就如挂那里一样,所有其他业务也都不执行,为一直等到消息到来才往下执行。 2、非阻塞 程序不会阻塞某一个函数,不等待消息到来,立即返回,往下执行。 举
  • 如果通过一个共享变量来标识生产者是否已经生产了一个数据可供消费者使用,那么未有数据被生产时候,消费者需要线程循环语句中检测该共享变量,一直循环等待直到有了数据可使用。这种交流方式叫做忙等待,忙...
  • 程序会阻塞某一个函数,而不往下执行,就如挂那里一样,所有其他业务也都不执行,为一直等到消息到来才往下执行。 2、非阻塞 程序不会阻塞某一个函数,不等待消息到来,立即返回,往下执行。 举
  • 其实 ,大家都知道,图片上传是很花时间……产品经理又觉得,那个界面一直来一个progressbar让用户等待不好,于是,就使用了后台来实现图片上传,并且,是断点续传,如果图片没有传完,下次打开,会继续传。...
  • 程序会阻塞某一个函数,而不往下执行,就如挂那里一样,所有其他业务也都不执行,为一直等到消息到来才往下执行。 2、非阻塞 程序不会阻塞某一个函数,不等待消息到来,立即返回,往下执行。 ...

空空如也

空空如也

1 2 3 4
收藏数 64
精华内容 25
关键字:

一直在等待的说说