精华内容
下载资源
问答
  • 多线程概述

    2015-11-25 17:25:23
    1、什么是多线程?  首先来明白一个进程概念,一个进程是指一个正在运行的应用程序,而线程就是进程的执行单元,是进程的一条执行路径。进程与线程的关系是:一个进程可以包括多条线程。所以多线程就是指一个应用...

    1、什么是多线程?

      首先来明白一个进程概念,一个进程是指一个正在运行的应用程序,而线程就是进程的执行单元,是进程的一条执行路径。进程与线程的关系是:一个进程可以包括多条线程。所以多线程就是指一个应用程序有多条执行路径。

      我们经常用的下载器,能够同时执行多个下载任务,这就是多线程,值得注意的是,经常使用的DOS窗口是单线程的,一条指令执行结束后才能执行下一条指令。

      值得注意的是:CPU每次只能执行一条线程,而且线程的执行具有随机性,不能知道某一时刻哪条线程得到CPU的执行权。

    2、为什么要使用多线程?

      如果程序是单线程的话,运行到某一步,假如说需要请求系统资源的时候,那么就会导致程序的阻塞(暂停),CPU就会空闲出来,就会造成资源浪费。如果我们在资源空闲的时候再创建出一条或多条线程,就能够充分的利用这些资源,使得CPU每时每刻都在工作,这样就最大效率的利用了CPU。单个进程可以有多个并发执行的线程,这样比只有一条线程执行效率要大多了。打个比方,以前这些活儿一个人干,现在有好多个人干,当然比一个人做效率高。

      所以说:多线程,为效率而生。

    3、实现多线程的方法?

    有两种。

    (1)继承 Thread 线程类

      步骤:

        A:定义一个类继承Thread类。

        B:子类要重写Thread类的run()方法(Thread类是抽象类,继承它必须重写run方法,在方法中定义本线程执行内容)。

        C:启动线程。

     实例:

      线程类:

    <span style="font-size:14px;"> //创建一个类继承Thread抽象类
    public class MyThread extends Thread {
    
    	//重写run方法
    	@Override
    	public void run() {
    		for (int x = 0; x < 100; x++) {
    			System.out.println(getName()+ x); //getName 在底层实际是this.getName,默认加上this
    		}
    	}
    }
    </span>
      测试类:

    <span style="font-size:14px;">public class ThreadDemo {
    	public static void main(String[] args) {
    
    		//实例化线程对象
    		MyThread my1 = new MyThread();
    		MyThread my2 = new MyThread();
    
    		//为线程对象设置名字
    		my1.setName("岳飞");
    		my2.setName("金兀术");
    
    		//启动线程,注意start方法内会自动调用run方法
    		my1.start();
    		my2.start();
    	}
    }
    </span>
      运行效果:当运行后,两个线程对象会争抢CPU资源,所以会争着打印自己的名字,又因为线程的随机性,所以打印出的名字没有规律性。

    (2)实现 Runnable 接口

      步骤:

        A:创建一个类实现 Runnable 接口

        B:重写run()方法

        C:创建类的实例

        D:把类的实现作为Thread的构造参数传递,创建Thread对象

     实例:

      线程类:

    <span style="font-size:14px;"> //定义类实现Runnable接口
    public class MyRunnable implements Runnable {
    	
    	//重写run方法
    	@Override
    	public void run() {
    		for (int x = 0; x < 100; x++) {
    			// Thread.currentThread()方法用于返回当前线程对象的引用
    			System.out.println(Thread.currentThread().getName() + x);
    		}
    	}
    }</span>
      测试类:

    <span style="font-size:14px;">public class MyRunnableDemo {
    	public static void main(String[] args) {
    
    		//实例化线程对象,只需创建一个即可
    		MyRunnable my = new MyRunnable();
    
    		Thread t1 = new Thread(my); //这个构造方法用于将实现Runnable接口的类转化为Thread类
    		Thread t2 = new Thread(my);
    
    		t1.setName("岳飞");
    		t2.setName("金兀术");
    
    		t1.start();//启动线程
    		t2.start();
    	}
    }</span>
      和上边的执行效果是一样的。

      比较:建议使用第二种,实现Runnable接口,因为这种方法避免了单继承的局限性(如果一个类已经有了父类,那么,它就不能再去继承Thread类)。而且,实现Runnable接口的方式只创建了一个线程类对象。

    4、线程的生命周期?

      线程的生命周期共分成五个阶段:

      小结:多线程,为效率而生。

    展开全文
  • MFC多线程编程多线程概述  进程和线程都是操作系统的概念。进程是应用程序的执行实例,每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成,进程在运行过程中创建的资源随着进程的终止而被销毁,所...
  • Java程序基础;多线程概述;多线程概述;线程与进程的比较;谢谢
  • Java多线程概述

    2016-03-15 20:58:49
    Java多线程概述 一、什么是多线程 理解几个概念: 多线程:一个应用程序有多条执行路径 进程:正在执行的应用程序 线程:进程的执行单元,执行路径 单线程:一个应用程序只有一条执行路径 多线程:一个...

    Java多线程概述

    一、什么是多线程

        理解几个概念:
          多线程:一个应用程序有多条执行路径
         进程:正在执行的应用程序
         线程:进程的执行单元,执行路径
         单线程:一个应用程序只有一条执行路径
         多线程:一个应用程序有多条执行路径
        多进程的意义?
            提高CPU的使用率。单进程的计算机只能做一件事情,而我们现在的计算机都可以做多件事情。
    	举例:一边玩游戏(游戏进程),一边听音乐(音乐进程)。
    	也就是说现在的计算机都是支持多进程的,可以在一个时间段内执行多个任务。
    	并且呢,可以提高CPU的使用率。
        多线程的意义?
            提高应用程序的使用率。多线程的存在,不是提高程序的执行速度。其实是为了提高应用程序的使用率。
    	程序的执行其实都是在抢CPU的资源,CPU的执行权。
    	多个进程是在抢这个资源,而其中的某一个进程如果执行路径比较多,就会有更高的几率抢到CPU的执行权。
    	我们是不敢保证哪一个线程能够在哪个时刻抢到,所以线程的执行有随机性。
    

    二、Java程序的运行原理及JVM的启动是多线程的

         Java的运行原理:Java命令去启动JVM,JVM会启动一个进程,该进程会启动一个主线程。
         JVM的启动是多线程的,因为它最低有两个线程启动了,主线程和垃圾回收线程。

    三、线程的调度和优先级问题

        线程的调度:分时调度和抢占式调度(Java采用的是抢占式调度)
       线程的优先级:默认为5.范围为1-10

    四、线程的生命周期

         线程的生命周期主要包括五个过程,分别为:新建、就绪、运行、阻塞、死亡。下边通过一幅图来理解整个生命周期。
        新建:创建线程对象
        就绪:有执行资格但是没有执行权,只有分配到时间片时才有执行权,去运行。
        运行:有执行的资格且有执行权,可以执行。
        阻塞:由于一些操作让线程处于该状态,没有执行资格,也没有执行权,但是另外一些操作可以将其激活,激活后处于就绪状态。
        死亡:线程对象变成垃圾,等待被回收。
    线程的生命周期图如下:
    
    
    展开全文
  • API-多线程(多线程概述,多线程实现方案,线程控制常见方法,线程安全问题及解决)

    1:多线程(理解)

           (1)多线程:一个应用程序有多条执行路径

                  进程:正在执行的应用程序

                  线程:进程的执行单元,执行路径

                  单线程:一个应用程序只有一条执行路径

                  多线程:一个应用程序有多条执行路径

                 

                  多进程的意义?

                         提高CPU的使用率

                  多线程的意义?

                         提高应用程序的使用率

    *多线程的存在,不是提高程序的执行速度。其实是为了提高应用程序的使用率。

    * 程序的执行其实都是在抢CPU的资源,CPU的执行权。

    * 多个进程是在抢这个资源,而其中的某一个进程如果执行路径比较多,就会有更高的几率抢到CPU的执行权。

    * 我们是不敢保证哪一个线程能够在哪个时刻抢到,所以线程的执行有随机性。

    *  注意两个词汇的区别:并行和并发。

    *            前者是逻辑上同时发生,指在某一个时间内同时运行多个程序。

    *            后者是物理上同时发生,指在某一个时间点同时运行多个程序。


           (2)Java程序的运行原理及JVM的启动是多线程的吗?

                  A:Java命令去启动JVM,JVM会启动一个进程,该进程会启动一个主线程。

                  B:JVM的启动是多线程的,因为它最低有两个线程启动了,主线程和垃圾回收线程。


    (3)多线程的实现方案(掌握)


    *public final String getName():获取线程的名称
    *public final void setName(String name):设置线程的名称
     针对不是Thread类的子类中如何获取线程对象名称呢?
    * public static Thread currentThread():返回当前正在执行的线程对象

    * Thread.currentThread().getName()

    A:继承Thread类

    public class MyThread extends Thread {
    
    	@Override
    	public void run() {
    		// 线程执行代码		
    		}
    	}
    }
    public class MyThreadDemo {
    	public static void main(String[] args) {
    		// 创建线程对象
    		// MyThread my = new MyThread();
    		// // 启动线程
    		// my.run();
    		// my.run();
    		// 调用run()方法为什么是单线程的呢?
    		// 因为run()方法直接调用其实就相当于普通的方法调用,所以你看到的是单线程的效果
    		// 要想看到多线程的效果,就必须说说另一个方法:start()
    		// 面试题:run()和start()的区别?
    		// run():仅仅是封装被线程执行的代码,直接调用是普通方法
    		// start():首先启动了线程,然后再由jvm去调用该线程的run()方法。
    		// MyThread my = new MyThread();
    		// my.start();
    		// // IllegalThreadStateException:非法的线程状态异常
    		// // 为什么呢?因为这个相当于是my线程被调用了两次。而不是两个线程启动。
    		// my.start();
    
    		// 创建两个线程对象
    		MyThread my1 = new MyThread();
    		MyThread my2 = new MyThread();
    
    		my1.start();
    		my2.start();
    	}
    }
    



    B:实现Runnable接口

    public class MyRunnable implements Runnable {
    
    	@Override
    	public void run() {
    		
    			// 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用			
    		
    	}
    
    }
    public class MyRunnableDemo {
    	public static void main(String[] args) {
    		// 创建MyRunnable类的对象
    		MyRunnable my = new MyRunnable();
    
    		// 创建Thread类的对象,并把C步骤的对象作为构造参数传递
    		// Thread(Runnable target)
    		// Thread t1 = new Thread(my);
    		// Thread t2 = new Thread(my);
    		// t1.setName("林青霞");
    		// t2.setName("刘意");
    
    		// Thread(Runnable target, String name)
    		Thread t1 = new Thread(my, "林青霞");
    		Thread t2 = new Thread(my, "刘意");
    
    		t1.start();
    		t2.start();
    	}
    }


    (4)线程的调度和优先级问题

                  A:线程的调度

                         a:分时调度

                         b:抢占式调度 (Java采用的是该调度方式)

                  B:获取和设置线程优先级

                         a:默认是5

                         b:范围是1-10


    (5)线程的控制(常见方法)

    A:休眠线程

    * public static void sleep(long millis)  休眠线程

    B:加入线程    

    * public final void join():等待该线程终止。

    C:礼让线程

    * public static void yield():暂停当前正在执行的线程对象,并执行其他线程。 

    * 让多个线程的执行更和谐,但是不能靠它保证一人一次。

    D:后台线程(守护线程)

    * public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。

    * 当正在运行的线程都是守护线程时,Java 虚拟机退出。 该方法必须在启动线程前调用。

    E:终止线程(掌握)

    * public final void stop():让线程停止,过时了,但是还可以使用。

    * public void interrupt():中断线程。 把线程的状态终止,并抛出一个InterruptedException。

    (6)线程的生命周期(参照线程生命周期图解.bmp)


    A:新建
    B:就绪
    C:运行
    D:阻塞
    E:死亡
    (7)电影院卖票程序的实现
    A:继承Thread类
    B:实现Runnable接口
    (8)电影院卖票程序出问题
    1:为了更符合真实的场景,加入了休眠100毫秒。
    2:卖票问题
    * A:相同的票卖了多次

    * CPU的一次操作必须是原子性的

    * B:出现了负数票

    * 随机性和延迟导致的

    (9)多线程安全问题的原因(也是我们以后判断一个程序是否有线程安全问题的依据)

    A:是否有多线程环境
    B:是否有共享数据
    C:是否有多条语句操作共享数据

    (10)同步解决线程安全问题

                  A:同步代码块

                         synchronized(对象) {

                                需要被同步的代码;

                         }

                        

                         这里的锁对象可以是任意对象。

                        

                  B:同步方法

                         把同步加在方法上。

                        

                         这里的锁对象是this

                        

                  C:静态同步方法

                         把同步加在方法上。

                        

                         这里的锁对象是当前类的字节码文件对象(反射再讲字节码文件对象)


    (11)回顾以前的线程安全的类

    A:StringBuffer
    B:Vector
    C:Hashtable
    D:如何把一个线程不安全的集合类变成一个线程安全的集合类

    用Collections工具类的方法即可。

    	// 线程安全的类
    		StringBuffer sb = new StringBuffer();
    		Vector<String> v = new Vector<String>();
    		Hashtable<String, String> h = new Hashtable<String, String>();
    
    		// Vector是线程安全的时候才去考虑使用的,但是我还说过即使要安全,我也不用你
    		// 那么到底用谁呢?
    		// public static <T> List<T> synchronizedList(List<T> list)
    		List<String> list1 = new ArrayList<String>();// 线程不安全
    		List<String> list2 = Collections
    				.synchronizedList(new ArrayList<String>()); // 线程安全


    展开全文
  • CVI多线程概述

    2013-06-27 12:36:36
    cvi的多线程讲解,有助于理解CVI下的多线程工作原理及其实现方法
  • Java 多线程(一)——多线程概述

    千次阅读 2016-03-02 21:16:44
    平时我们一般编写的程序都是单线程程序,只有一条顺序执行流——程序从main()方法开始执行,一步一步向下执行直到main方法结束。... 多线程的程序区别于单线程,即可以包含多个顺序执行流,多个顺序流之间互不干扰。

    1 多线程概述

      平时我们一般编写的程序都是单线程程序,只有一条顺序执行流——程序从main()方法开始执行,一步一步向下执行直到main方法结束。这种情况,如果程序执行某行代码时遇到阻塞,那么程序将会停滞在该处。
      多线程的程序区别于单线程,即可以包含多个顺序执行流,多个顺序流之间互不干扰。打个比方:单线程的程序如同只有一个服务员的餐厅,只有做完一件事他才可以做下一件事;而多线程的程序就是有很多个服务员的餐厅,他们可以同时做很多件事情。

    2 线程与进程

    2.1 进程

      几乎所有的操作系统都支持同时运行多个任务,一个任务通常就是一个程序,每个运行中的程序就是一个进程(Process)。当一个程序运行时,内不可能包含了多个顺序执行流,每个顺序执行流就是一个线程。
      进程具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位。进程的特征:

    • 独立性:进程是系统中独立的实体,拥有自己独立的资源,拥有自己私有的地址空间。
    • 动态性:进程是一个正在执行程序的实例,拥有自己的生命周期和各种状态。
    • 并发性:多个进程可以在单个处理器上并发执行,多个进程之间不会互相影响。

    现代操作系统都支持多进程的并发,但在具体的实现细节上可能因为硬件和操作系统的不同而采用不同的策略。比如共用式的多任务操作策略、抢占式多任务操作策略。

    并发与并行

    并发性(concurrency):两个或多个事件在同一时间间隔内发生。即指在同一时刻只能有一条指令执行,但多个进程指令被快速轮换执行。
    并行性(parallel):两个或者多个事件在同一时刻发生。即指在同一时刻,有多条指令在多个处理器上同时执行;

    2.2 线程

      多线程扩展了多进程的概念,即一个进程可以同时并发(或并行)处理多个任务。
      线程(Thread)是进程的执行单元,像进程在操作系统的地位一样。一个进程可以拥有多个线程,一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量,但不拥有资源,它与父进程的其他线程共享该进程所拥有的全部资源。
      线程是独立运行的,它并不知道进程中是否还有其他线程存在。线程的执行时抢占式的,即当前运行的线程在任何时候都可能被挂起,以便另外一个线程可以运行。
      线程的调度和管理由进程本身完成。

    2.3 小总结

      操作系统可以同时执行多个任务,每个任务就是进程;进程可以同时执行多个任务,每个任务就是线程。
      一个程序运行后至少有一个进程,一个进程里可以包含多个线程,但至少要包含一个线程(主线程,即Java中的main()方法执行后的线程)。

    3 多线程的好处

    3.1 为什么要多线程

    1. 在许多应用中同时发生着多种活动,其中某些活动随着时间的推移会被阻塞。通过将这些应用程序分解成可以准并行运行的多个顺序线程,程序设计模型会变得更简单。
    2. 由于线程比进程更轻量级、所以它们比进程更容易创建,也容易撤销。同时因为多个线程共享父进程里的全部资源,因此编程更加方便。
    3. 在性能方面,若多个线程都是CPU密集型(进程占用CPU时间较长)的,那么并不能获得性能上的增强,但是如果存在着大量的计算和大量的I/O处理,即I/O密集型的,那么拥有多个线程允许这些活动彼此重叠进行,从而会加快应用程序执行的速度。

    3.2 多线程编程的优点

    1. 进程之间不能共享内存,但线程之间共享内存非常容易
    2. 系统创建进程时需要为该进程重新分配系统资源,但创建线程则代价小得多,因此使用多线程来实现多任务并发比多进程的效率高
    3. Java语言内置了多线程功能支持,而不是单纯地作为底层操作系统的调度方式,从而简化了Java的多线程编程。

    3.3 多线程的例子

    1. 一个浏览器能同时下载多个图片
    2. 一个web服务器能同时响应多个用户请求
    3. Java虚拟机在后台提供了一个超级线程来进行垃圾回收
    4. 图形用户界面(GUI)应用需要启动单独的线程从主机环境收集用户界面事件
    5. ……

    4 进程或线程的调度

      当计算机系统是多道程序设计系统时,通常就会有多个进程或线程同时竞争CPU。只要有两个或多个的进程处于就绪状态,这种情形就会发生。如果只有一个CPU可用,那么久必须选择下一个要运行的进程。操作系统中完成这一部分的是调度程序(scheduler),该程序使用的算法是调度算法(scheduling algorithm)。

    4.1 调度算法

    不同的环境需要不同的调度算法。

    批处理系统中的调度

    1. 先来先服务(first-come-first-served)
      非抢占式的先来先服务算法。
    2. 最短作业优先(shortest job first)
      非抢占式
      只有在所有的作业都可同时运行的情况下,最短作业优先算法才是最优化的。
    3. 最短剩余时间优先(shortest remaining time next)
      最短作业优先的抢占式版本是最短剩余时间优先。

    交互式系统中的调度

    1. 轮转调度(Round-robin)

    2. 优先级调度(Priority scheduling)

    3. 多级队列和多级反馈队列(Multi Queue & Multi-level Feedback)

    4. Guaranteed Scheduling, Lottery Scheduling, and Fair Sharing Scheduling

    实时系统中的调度

    1. 静态调度

    2. 动态调度

    展开全文
  • Java---10---多线程概述

    2014-12-09 22:57:36
    多线程概述: 进程和线程是现代操作系统中的两个必不可少的运行模式。在操作系统中可以有多个进程,包括系统进程(由操作系统内部建立的进程)和用户进程(由用户建立的进程);一个进程中可以有多个线程。 ...
  • iOS学习笔记08—多线程概述

    千次阅读 2012-12-19 15:44:15
    iOS学习笔记08—多线程概述 一、概述 线程(thread):用于指代独立执行的代码段。 进程(process):用于指代一个正在运行的可执行程序,它可以包含多个线程。 任务(task):用于指代抽象的概念,表示需要...
  • 2.1、多线程概述 2.1.1、使用多线程的原因 在开发windows应用程序的时候,经常会遇到一些通讯类的需求。比如应用程序中有一个功能是要监听来自别的应用的TCP请求,那么一旦开始监听之后,程序就会处于等待状态,...
  • java中的多线程 概述

    2011-07-13 14:55:00
    转帖自:http://developer.51cto.com/art/200512/15883.htm 一、线程概述线程是程序运行的基本执行单元。当操作系统(不包括单线程的操作系统,如微软早期的DOS)在执行一个程序时,会在系统中建立一个进程,而在这个...
  • 概述一个运行的程序成为一个进程,同一个进程又可以分为个独立运行的执行流,成为线程。属性和方法基本操作:启动线程 线程休眠 销毁线程 设置ThreadState属性 设置优先级和线程池 线程在System.Threading命名...
  • 多线程之一,多线程概述

    千次阅读 2005-06-23 13:04:00
    线程的创建 使用CreateThread函数创建线程,CreateThread的原型如下:HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,DWORD dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter...
  • JAVA之旅(十一)——RuntimeException,异常的总结,Package,jar包,程序概述 继续JAVA之旅 一.RuntimeException 在Exception种有一个特殊的子类异常RuntimeException,翻译过来就是运行异常,如果在函数内容...
  • 在IDEA中Thread.activeCount()=2,除了main方法的主线程外还有,还了一个预期外的 Monitor Ctrl-Break 线程 public class threadActiveCount { public static void main(String[] args) { //打印当前线程组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 136,614
精华内容 54,645
关键字:

多线程概述