`

更好的把握线程<一>:Thread (线程)介绍

阅读更多
线程(引用自Java API doc):
引用
线程 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。


线程的一些特性:
  • 所有的Java代码都是在某个线程中执行的,所以在任一行Java代码中使用Thread.currentThread()都可以得到当前运行线程。
  • JVM允许多个线程并发执行,虽然同一时刻只能有一个线程占用CPU,但每个线程占有的时间片非常短,所以人类的感官上多个线程是并发执行的。
  • 当 JVM启动时,至少有一个用户线程运行,即执行某个类的main方法的线程。


线程在下列情况之一终止运行:
  • Thread.run方法运行完毕(或者是Thread包含的Runnable对象的run方法执行完毕)
  • run方法内的代码运行时发生异常。


JVM在下列情况下终止运行:
  • 所有非守护线程(即用户线程,非daemon线程)终止。假如有main线程和另外一个用户线程在运行,即使main线程终止了,还必须等待另外一个线程终止JVM才会终止。
  • 调用了Runtime类的exit方法(启动虚拟机的关闭序列)。
  • 外部程序强行终止虚拟机执行(非正常退出)。


创建线程:
[list]
  • 继承Thread类,覆盖run方法
  • 实现Runnable接口,通过Thread类的带Runnable参数的构造函数传入到Thread对象内,一种常用的方式:
  • Thread t=new Thread(new Runable(){
      public void run(){
         //do something
      } 
    });
    

    [/list]
    运行线程:
    • 调用Thread的start方法,调用之后,JVM启动一个新的线程,在新线程中执行该线程对象的run方法。
    • 线程启动之后,不能再调用start方法,否则会抛出IllegalThreadStateException

    线程的一些自动继承的特性:
    • 如果未指明优先级,则被创建的线程和创建它的线程具有相同优先级。
    • 如果未指明ThreadGroup,则被创建的线程和创建它的线程使用相同的ThreadGroup。如果指定ThreadGroup为null,则系统会自动将本线程加入系统级的ThreadGroup。所以说不存在没有ThreadGroup的线程。
    • 如果未指明是否守护线程,则被创建的线程和创建它的线程具有相同的daemon属性。也就是说守护线程创建的线程如果未特别指定,则是守护线程,用户线程创建的线程如果未特别指定,则是用户线程。main线程是用户线程,除非被Thread.currentThread().setDaemon(true)方式改变。(根据oxromantic的指正,此处是错误的,正在运行的线程如果调用setDaemon会抛出java.lang.IllegalThreadStateException异常,main线程肯定是正在运行的,setDaemon只有在start()方法之前调用才有效。感谢oxromantic指正)
    守护线程和用户线程:
    [list]
  • 当最后一个用户线程终止的时候,所有守护线程将被“终止”(不是被interrupt),虚拟机退出。即使守护线程是个死循环。以下代码放入main方法里:
  • //请等待足够久的时间(可能是1-2分钟),程序会自动停止。
    Thread t1=new Thread(){
     public void run(){
      int i=0;
      while(true){//死循环
       i++;
       System.out.println(i);
       //Thread.yield();//如果想让t2有机会更快完成,需要调用yield让出CPU时间。
      }
     }
    };
    t1.setDaemon(true);//注释掉这句就可以看出区别了。
    Thread t2=new Thread(){
     public void run(){
      int i=50000;
      while(i>0){
       i--;
      }
      System.out.println("t2 done");
     }
    };
    t1.start();
    t2.start();
    

    [/list]
    线程优先级:
    • 线程优先级范围是1-10,1最低优先级10最高优先级。
    • 优先级越高越先被JVM从“等待运行”(waiting-to-run)的状态挑选出来运行。
    • JVM线程和操作系统线程的关系有2种(甚至可能是3种,依赖于平台和JVM实现):
    •   [list=1]
       
    • n-1关系,所有JVM线程都在同一个OS线程中运行。
    •  
    • n-m关系,一个JVM线程是可以在多个OS线程中运行,一个OS线程可运行多个JVM线程,不管硬件是多核还是单核。
    •  
    • 1-1关系,一个JVM线程对应一条OS进程。(早期JVM的在Linux上的实现版本)
    •  

    所以,线程的优先级设置是不可靠的,依赖于JVM实现和OS。.NET线程5个等级:Highest,AboveNormal,Normal,BelowNormal,Lowest.Solaris有15个等级,最高的5个等级是给进程中断层级(Process Interrupt Levels ,PILs)使用。也就是说PIL可以中断普通进程知道执行直到其运行结束。剩下的10个优先级可以被线程使用。所以优先级8和9可能并没有区别。默认优先级是5,最大优先级由所在ThreadGroup的maxPriority决定。也就是说所属ThreadGroup最大优先级是8则,以构造函数Thread(ThreadGroup g,String name)所创建的线程即使将其设置为10,优先级仍然是8.
  • 当等待运行的线程中有3种优先级相差比较大的线程在运行的时候,单任务操作系统会按高-中-低的顺序来执行线程,也就是说先跑完所有高等级的再跑低等级的,多任务操作系统则会间歇执行,但不保证高优先级的、相同任务内容的任务会更快完成,即使你让线程跑上10分钟。非常诡异,可能跟CPU是双核有关(但用3个优先级且混合启动线程还是有可能高优先级的跑输给低优先级的,哪怕是最高10和最低1)。
  • 给出代码,请读者分别在Linux和Windows下测试,有条件的话在Solaris上也试试。给个报告出来。
    	public static void main(String[] args) throws Exception {
    		int x=211;//210个线程分3组,每组70个,第211是“发令枪”
    		int n=0;//a类线程数量,本类线程优先级最高
    		int m=0;//b类线程数量,本类线程优先级最低
    		int l=0;//c类线程数量,本类线程优先级中间(5)
    		
    		final CyclicBarrier cb=new CyclicBarrier(x);//发令枪类,让所有线程理论上在同一起跑线(也许和逐个逐个start没区别)
    		final List ln=new ArrayList(7);//存放a类线程的列表,为了在匿名类中可见,定义为final,7原本是21个线程在跑,后来为了理论上消除误差,增加到70个,此处没有修改过来。
    		final List lm=new ArrayList(7);//存放b类线程的列表
    		final List ll=new ArrayList(7);//存放c类线程的列表
    		for(int i=0;i<x-1;i++){//为了避免线程在创建的时候同类线程扎堆(理论上可能)产生误差,打乱创建过程。为了避免2组线程分别在双核CPU上各自单核上运行,采用了3组线程。
    			Runner t=null;
    			if(i%3==0){
    				t=new Runner(cb,"a"+i);
    				t.setPriority(8);//可以用10,但测试结果看不出区别。
    				ln.add(t);
    				n++;
    			}else if(i%3==1){
    				t=new Runner(cb,"b"+i);
    				t.setPriority(2);//可以用1,
    				lm.add(t);
    				m++;
    			}else{
    				t=new Runner(cb,"c"+i);
    				t.setPriority(5);
    				ll.add(t);
    				l++;
    			}
    			t.start();//不是真的启动线程哦。请看Runner类
    		}
    		System.out.println(n);//检验是不是每组70个。
    		System.out.println(m);
    		System.out.println(l);
    		
    		try {
    			Thread.sleep(3000);//本意是为了让Runner在起跑线都预备好,在此停3秒。减少误差。
    			Timer timer =new Timer(true);//定时打印结果的线程。
    			timer.scheduleAtFixedRate(new TimerTask(){
    
    				@Override
    				public void run() {//定时打印每组线程的结果的平均值,由于打印是有先后顺序的,所以使用平均值,消除时间差(用心良苦啊。。。)
    					System.out.println("a avg--"+getAvg(ln));//可以将a组的结果放在最后,结果通常还是a最慢
    					System.out.println("b avg--"+getAvg(lm));
    					System.out.println("c avg--"+getAvg(ll));
    				}
    				
    				
    			}, 3000, 3000);//3秒打印一次。
    			cb.await();//发令枪响。
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (BrokenBarrierException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.out.println("started ");
    		
    		
    	}
    	
    	
    	public static BigInteger getAvg(List l){//为什么用大整数?因为long,和int我都试过得不到想要的结果。
    		BigInteger total=BigInteger.valueOf(0);
    		for (Iterator iter = l.iterator(); iter.hasNext();) {
    			Runner r = (Runner) iter.next();
    			total=total.add(r.getCountPerMs());
    		}
    		return total.divide(BigInteger.valueOf(l.size()));//同组线程的结果的平均值
    	}
    	
    	static class Runner extends Thread{//有心人可以试试改成只实现Runnable接口
    		private CyclicBarrier cb;
    		private String name;
    		private BigInteger count=BigInteger.valueOf(0);
    		private long startTime;
    		public Runner(CyclicBarrier cb,String name){
    			this.cb=cb;
    			this.name=name;
    		}
    		public void run(){
    			try {
    				cb.await();//让其在起跑线上等待其他线程和发令枪声
    				System.out.println(this.name+"start");//看看各个线程真正跑起来是否一致,不怕,每组有70条,一条拖后退问题不大,只要运行时间够长,体力好的应该还是不会输在起跑线的。
    				
    				startTime=System.currentTimeMillis();//原本是为了消除时间差使用的,效果不好,改用发令枪,留着成了僵尸代码
    				for (;;) {
    					count=count.add(BigInteger.valueOf(1));
    					Thread.sleep(1);//调试手段,为了使线程慢跑,可以去掉对比结果。
    //					if(count%10000==0){
    //						Thread.yield();//调试手段,效果不明显,也毙掉了。
    //					}
    //					if(count.mod(m)==0){
    //						String info = name+":"+(count/100000)+"--"+this.getPriority()+"-"+this.isDaemon();
    ////						System.out.println(info);//早期调试手段,毙掉。
    //					}
    				}
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			} catch (BrokenBarrierException e) {
    				e.printStackTrace();
    			}
    			 
    		}
    		public BigInteger getCountPerMs(){
    //			long value=System.currentTimeMillis()-startTime;
    ////			System.out.println(value);
    ////			System.out.println("count "+this.count);
    //			if(value==0)return BigInteger.valueOf(0);
    //			return this.count.divide(BigInteger.valueOf(value));
    //以上一大段注释掉的代码原本是为了消除时间差的。没啥效果,毙掉
    			return this.count;
    		}
    	}
    
    

    结果大大出乎意料,通常a跑得最慢,b跑得最快.......
    理论估计:会不会是a优先级高切换太频繁,切换的开销大过运行的开销??,猜测,高手可以指点一下。
    结论:不要依赖线程之间的竞争来得到想要的结果。
    [/list]
    先写到这,下一节开讲线程的使用技巧和设计思想。

    分享到:
    评论
    7 楼 llade 2008-12-30  
    oxromantic 写道
    这种自己不认真验证的文章真是误人子弟
    Thread.currentThread().setDaemon(true)
    你倒是设给我看看

    引用
        /**
         * Marks this thread as either a daemon thread or a user thread. The
         * Java Virtual Machine exits when the only threads running are all
         * daemon threads.
         * <p>
         * This method must be called before the thread is started.
          * <p>
         * This method first calls the <code>checkAccess</code> method
         * of this thread
         * with no arguments. This may result in throwing a
         * <code>SecurityException </code>(in the current thread).
        *
         * @param      on   if <code>true</code>, marks this thread as a
         *                  daemon thread.
         * @exception  IllegalThreadStateException  if this thread is active.
         * @exception  SecurityException  if the current thread cannot modify
         *               this thread.
         * @see        #isDaemon()
         * @see        #checkAccess
         */
        public final void setDaemon(boolean on)

    谢谢你的指正。的确是无法修改已启动的用户线程的为守护线程。感谢你那么仔细的阅读拙作
    6 楼 oxromantic 2008-12-30  
    这种自己不认真验证的文章真是误人子弟
    Thread.currentThread().setDaemon(true)
    你倒是设给我看看

    引用
        /**
         * Marks this thread as either a daemon thread or a user thread. The
         * Java Virtual Machine exits when the only threads running are all
         * daemon threads.
         * <p>
         * This method must be called before the thread is started.
          * <p>
         * This method first calls the <code>checkAccess</code> method
         * of this thread
         * with no arguments. This may result in throwing a
         * <code>SecurityException </code>(in the current thread).
        *
         * @param      on   if <code>true</code>, marks this thread as a
         *                  daemon thread.
         * @exception  IllegalThreadStateException  if this thread is active.
         * @exception  SecurityException  if the current thread cannot modify
         *               this thread.
         * @see        #isDaemon()
         * @see        #checkAccess
         */
        public final void setDaemon(boolean on)
    5 楼 hdware 2008-12-30  
    收藏了,慢慢看,最近被进程搞死了
    4 楼 llade 2008-06-12  
    本人INTEL T2050 CPU,双核。系统是WindowsXP
    3 楼 llade 2008-06-12  
    把A组放在后面统计,我的运行结果如下,A组反而落后于B组
    70
    70
    70
    b16start
    c17start
    a18start
    c20start
    b19start
    a21start
    b22start
    c23start
    a24start
    b25start
    c26start
    a27start
    b28start
    c29start
    a30start
    b31start
    c32start
    a33start
    b34start
    c35start
    a36start
    b37start
    c38start
    a39start
    b40start
    c41start
    a42start
    b43start
    c44start
    a45start
    b46start
    c47start
    a48start
    b49start
    c50start
    a51start
    b52start
    a54start
    b55start
    c56start
    a57start
    b58start
    c59start
    a60start
    b61start
    c62start
    a63start
    b64start
    a66start
    c65start
    b67start
    c68start
    a69start
    b70start
    c71start
    a72start
    b73start
    c74start
    a75start
    b76start
    c77start
    a78start
    b79start
    c80start
    a81start
    b82start
    c83start
    a84start
    b85start
    c86start
    a87start
    b88start
    c89start
    a90start
    b91start
    c92start
    a93start
    b94start
    c95start
    a96start
    b97start
    c98start
    a99start
    b100start
    a15start
    c53start
    c101start
    b103start
    a105start
    c107start
    b109start
    a111start
    c113start
    b115start
    a117start
    c119start
    b121start
    b124start
    a123start
    a126start
    c125start
    c128start
    b127start
    b130start
    a129start
    a132start
    c131start
    b133start
    a135start
    c137start
    b139start
    c140start
    a141start
    b142start
    c143start
    a144start
    b145start
    c146start
    a147start
    b148start
    c149start
    a150start
    b151start
    c152start
    a153start
    b154start
    c155start
    a156start
    b157start
    c158start
    a159start
    b160start
    c161start
    a162start
    c134start
    b163start
    c164start
    a165start
    b166start
    c167start
    a168start
    b169start
    c170start
    a171start
    c173start
    b175start
    c176start
    a177start
    c179start
    b181start
    c182start
    a183start
    c185start
    a186start
    b187start
    c188start
    a189start
    b190start
    c191start
    a192start
    b193start
    a195start
    b196start
    c197start
    a198start
    b199start
    c200start
    a201start
    b202start
    c203start
    a204start
    b205start
    c206start
    a207start
    c209start
    a108start
    b112start
    a114start
    c116start
    b118start
    a120start
    c122start
    b136start
    a138start
    b172start
    b178start
    a180start
    b184start
    b208start
    started 
    b1start
    a0start
    c2start
    a3start
    b4start
    c5start
    a6start
    b7start
    c8start
    a9start
    b10start
    c11start
    a12start
    b13start
    c14start
    c194start
    a174start
    a102start
    c104start
    b106start
    c110start
    b avg--94766
    c avg--94174
    a avg--115073
    b avg--224373
    c avg--216470
    a avg--207931
    b avg--341876
    c avg--344409
    a avg--332709
    b avg--466582
    c avg--466450
    a avg--448567
    b avg--659035
    c avg--653320
    a avg--638056
    b avg--784288
    c avg--776086
    a avg--770561
    b avg--908349
    c avg--898104
    a avg--894808
    b avg--1021412
    c avg--1026939
    a avg--1015154
    b avg--1141776
    c avg--1147952
    a avg--1131192
    b avg--1266781
    c avg--1270811
    a avg--1246034
    2 楼 wkbulletin 2008-06-12  
    70
    70
    70
    started 
    a21start
    c140start
    c20start
    a24start
    c23start
    b133start
    b82start
    c83start
    a84start
    b19start
    b13start
    c86start
    a27start
    a87start
    b136start
    b139start
    a141start
    c143start
    a144start
    b145start
    c146start
    a147start
    b148start
    a150start
    c149start
    b151start
    c152start
    a153start
    b142start
    b154start
    c155start
    a156start
    c158start
    a159start
    b157start
    a162start
    b88start
    a30start
    c29start
    b163start
    c164start
    c26start
    c32start
    a165start
    a33start
    a0start
    c35start
    a6start
    c167start
    a36start
    c2start
    b166start
    a168start
    c161start
    b169start
    c170start
    b28start
    a171start
    b172start
    c173start
    a174start
    b175start
    c176start
    a177start
    b178start
    c179start
    a180start
    b85start
    b181start
    c182start
    a183start
    a90start
    c38start
    c89start
    b160start
    b37start
    b184start
    c185start
    a186start
    b187start
    c188start
    a189start
    a192start
    c191start
    b193start
    c194start
    b190start
    a195start
    b196start
    c197start
    a198start
    b199start
    c200start
    a201start
    b202start
    a39start
    b22start
    a204start
    c203start
    c92start
    a93start
    c5start
    a42start
    c41start
    c95start
    b91start
    b40start
    b94start
    a96start
    b25start
    b31start
    a3start
    c98start
    a45start
    a99start
    b97start
    b205start
    c206start
    a207start
    b208start
    c209start
    c47start
    c101start
    b7start
    b100start
    a48start
    a102start
    c44start
    b103start
    a51start
    a105start
    c50start
    c104start
    b4start
    a9start
    a108start
    b109start
    c110start
    a54start
    c8start
    a111start
    b112start
    c107start
    c113start
    a114start
    b106start
    b115start
    c11start
    c116start
    c53start
    a117start
    b49start
    b118start
    a57start
    a120start
    c119start
    b34start
    b46start
    b52start
    b55start
    b43start
    c122start
    a60start
    a123start
    c59start
    c56start
    b124start
    c125start
    a63start
    c62start
    b61start
    a126start
    b58start
    a12start
    b127start
    b121start
    c128start
    a72start
    a66start
    a129start
    b10start
    b70start
    b64start
    a69start
    c65start
    c71start
    c68start
    c131start
    b1start
    b130start
    a132start
    c74start
    b16start
    a138start
    b73start
    a15start
    a75start
    c137start
    c134start
    a135start
    a78start
    c77start
    c14start
    a18start
    b76start
    b67start
    b79start
    c17start
    c80start
    a81start
    a avg--1508
    b avg--1481
    c avg--1501
    a avg--3003
    b avg--2938
    c avg--2977
    a avg--4520
    b avg--4427
    c avg--4481
    a avg--6033
    b avg--5908
    c avg--5982
    a avg--7552
    b avg--7396
    c avg--7487
    a avg--9069
    b avg--8889
    c avg--8993
    a avg--10586
    b avg--10376
    c avg--10499
    a avg--12104
    b avg--11869
    c avg--12007
    a avg--13625
    b avg--13363
    c avg--13513
    a avg--15139
    b avg--14851
    c avg--15018
    a avg--16658
    b avg--16335
    c avg--16521
    a avg--18177
    b avg--17782
    c avg--18015
    a avg--19697
    b avg--19260
    c avg--19518
    a avg--21216
    b avg--20713
    c avg--21005
    a avg--22737
    b avg--22210
    c avg--22511
    a avg--24255
    b avg--23703
    c avg--24018
    a avg--25771
    b avg--25192
    c avg--25522
    1 楼 tianhaoleng 2008-06-12  
    期待楼主续作!我觉得写的很好。

    相关推荐

      QT多线程技术读取文档内容到程序里

      为了防止直接读取文件里的内容太大而发生卡顿,于是多线程读取将更高效的解决这个问题。 效果图如下: 其中pro文件无需改动,默认就好,头文件h里面的内容为 #ifndef MAINWINDOW_H #define MAINWINDOW_H #...

      调试器ThreadTracer

      在项目中嵌入类CThreadTrace类,然后生成一个全局对象&lt;br&gt;CXXXXApp theApp;&lt;br&gt;CThreadTrace ThreadTracer; //调试类&lt;br&gt;则在程序任何地方...&lt;br&gt;祝大家使用愉快,同时可以任意修改,修改好发送一份给我更是感激不尽。

      java并发编程:线程基础

      通过深入学习,您将建立扎实的多线程编程基础,能够更好地理解和应用多线程编程。 多线程概述: 简要介绍多线程编程的重要性和应用场景。解释为什么多线程可以提高程序性能和资源利用率。 线程的创建: 详细讲解线程...

      代码客:Iocp Tcp Server(G-TcpServer) 1.0 Demo源码

      可通过OnThread事件回调函数设置线程权限。在此线程模式下,应用层可以在回调函数里处理数据而不必再建立另外的数据处理线程池。 2、线程平衡 为使连接能平衡使用处理线程,每个连接同时只有一个处理线程处理工作...

      linux系统编程之线程.zip

      为了防止新创建的线程还没有得到执行就终止,我们在main函数return之前延时1秒,这只是一种权宜之计,即使主线程等待1秒,内核也不一定会调度新创建的线程执行,下一节我们会看到更好的办法。 【练习】:循环创建多...

      用PB编写多线程应用程序

      多线程是指一个程序内部同时执行的多个流程,与单线程相比,它至少有两个方面的优点:第一,它可以更好地利用系统资源,比如CPU,若一个线程因I/O操作受阻,另一个线程仍可利用CPU来执行;第二,它更好地满足了客户...

      多线程网络传输

      使用ReadBuffer(),Send()函数来接收发送Buffer内字节,这样作的目的是使程序具有更好的灵活性。你可以自定义Buffer内那些字节的含义,例如是字符串、图像、声音、命令等等。 文件的多线程读写采用windows内存映像...

      thready:Nim中线程的备用接口

      Thready-更好的线程API。 :warning: 警告:该库是一个WIP,尚不能使用。 :warning: 线程化的目的是使线程的工作尽可能简单。 该库仅适用于--gc:arc或--gc:orc。 不支持其他GC。 Thready将复杂的线程主题提炼为...

      java多线程设计模式详解(PDF及源码)

      第一章相关线程设计模式的介绍,都举一反三使读者学习更有效。最后附上练习问题,让读者可以温故而知新,能快速地吸收书中的精华,书中最后附上练习问题解答,方便读者学习验证。 目录 漫谈UML UML 类图 类和层次...

      java多线程介绍

      主要是讲解了一些多线程的相关知识,可以帮助不熟悉多线程的朋友,更好的学习多线程

      java多线程编程_java多线程_

      4.讲解了synchronized关键字 , 它使用起来比较麻烦, 所以在Java5中提供了Lock 对象 , 以求能更好地实现并发访问时的同步处理, 包括读写锁等相关技术点。5.讲解了Timer定时器类, 其内部实现就是使用的多线程技术...

      多线程网络传输 v1.0

      使用ReadBuffer(),Send()函数来接收发送Buffer内字节,这样作的目的是使程序具有更好的灵活性。你可以自定义Buffer内那些字节的含义,例如是字符串、图像、声音、命令等等。文件的多线程读写采用windows内存映像...

      C#基于异步事件回调多线程容器

      队列采用线程安全的BlockingCollection,每组工作者用一个队列。委托采用Func来定义的,没有采用传统且不太好理解的Delegate。这让代码减少很多,也更容易理解。多线程应该采用消息中心来交换数据,这样就规避了线程...

      concurrent 多线程 教材

      32 Java 理论与实践 构建一个更好的 HashMap.mht 33 Java 理论与实践 JDK 5_0 中更灵活、更具可伸缩性的锁定机制.mht 34 Java 理论与实践 流行的原子.mht 35 Java 理论与实践 非阻塞算法简介.mht 36 Java 理论与...

      Flutter渲染机制—UI线程

      Flutter相比RN性能更好,由于Flutter自己实现了一套UI框架,丢弃了原生的UI框架,非常接近原生的体验。为了揭秘Flutter高性能,本文从源码角度来看看Flutter的渲染绘制机制,跟渲染直接相关的两个线程是UI线程和GPU...

      c#多线程线程池和异步编程

      我们将在这里进一步讨论一些.NET类,以及他们在多...但是如果有大量的线程,考虑使用线程池应该更好一些,它提供了高效的线程管理机制来处理多任务。 对于定期的执行任务Timer类是合适的;使用代表是异步方法调用的首选。

      服务器、客户端多线程传送文件

      使用ReadBuffer(),Send()函数来接收发送Buffer内字节,这样作的目的是使程序具有更好的灵活性。你可以自定义Buffer内那些字节的含义,例如是字符串、图像、声音、命令等等。 文件的多线程读写采用windows内存映像...

      Java创建线程的两个方法

      Java提供了线程类Thread来创建多线程的程序。其实,创建线程与创建...相比而言,哪一种方法更好呢?  在Java中,类仅支持单继承,也是说,当定义一个新的类的时候,它只能扩展一个外部类.这样,如果创建自定义线程

      C#传递参数到线程的方法汇总

      首先我们要知道什么是线程,什么时候要用到线程,如何去使用线程,如何更好的利用线程来完成工作。 线程是程序可执行片段的最小单元,是组成运行时程序的基本单元,一个进程有至少一个线程组成。一般在并行处理等待...

      C#中传递参数到线程的N个方法

       首先我们要知道什么是线程,什么时候要用到线程,如何去使用线程,如何更好的利用线程来完成工作。  线程是程序可执行片段的小单元,是组成运行时程序的基本单元,一个进程有至少一个线程组成。一般在并行处理...

    Global site tag (gtag.js) - Google Analytics