精华内容
下载资源
问答
  • 1.object-c中创建线程的方法

    1.object-c中用NSThread创建线程的方法:

      NSThread *oneThread=[[NSThread alloc]initWithTarget:self selector:@selector(sayMethod) object:nil];
      
        [oneThread start];
        
    
      还可以是

    [self performSelectorInBackground:@selector(sayMethod) withObject:nil];
    

    也可以是

     [NSThread detachNewThreadSelector:@selector(sayMethod) toTarget:self withObject:nil];
    

    2.object-c中用NSOperation创建线程的方法

      NSOperationQueue *queue=[[NSOperationQueue alloc]init];
        [queue addOperationWithBlock:^{
            [NSThread sleepForTimeInterval:3];
            NSString *str=@"nice to meet you";
            ;
            [[NSOperationQueue mainQueue]addOperationWithBlock:^{
                UILabel *onelabel=[[UILabel alloc]initWithFrame:CGRectMake(100, 100, 100, 100)];
                [self.view addSubview:onelabel];
                onelabel.text=str;
            }];
        }];
    
    3.object-c中用GCD创建线程的方法

     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [NSThread sleepForTimeInterval:3];
            NSString *str=@"nice to meet you";
            NSLog(@"%@",str);
            dispatch_async(dispatch_get_main_queue(), ^{
                UILabel *onelabel=[[UILabel alloc]initWithFrame:CGRectMake(100, 100, 100, 100)];
                [self.view addSubview:onelabel];
                onelabel.text=str;
            });
        });

    NSOperationQueue gives finer control with what you want to do. You can create dependencies between the two operations (download and save to database). To pass the data between one block and the other, you can assume for example, that a NSData will be coming from the server so:
    block 代码端这个还不是很懂

    __block NSData *dataFromServer = nil;
    NSBlockOperation *downloadOperation = [[NSBlockOperation alloc] init];
    __weak NSBlockOperation *weakDownloadOperation = downloadOperation;
    
    [weakDownloadOperation addExecutionBlock:^{
     // Download your stuff  
     // Finally put it on the right place: 
     dataFromServer = ....
     }];
    
    NSBlockOperation *saveToDataBaseOperation = [[NSBlockOperation alloc] init];
    __weak NSBlockOperation *weakSaveToDataBaseOperation = saveToDataBaseOperation;
    
     [weakSaveToDataBaseOperation addExecutionBlock:^{
     // Work with your NSData instance
     // Save your stuff
     }];
    
    [saveToDataBaseOperation addDependency:downloadOperation];
    
    [myQueue addOperation:saveToDataBaseOperation];
    [myQueue addOperation:downloadOperation];


    在主线程中执行代码用什么方法?



    展开全文
  • 创建线程的方法

    2016-09-18 16:32:13
    从操作系统的角度来看,线程是CPU调度的最小单位——可以理解为一种资源、权利,即能够获得CPU的使用权网上很多文章中说java创建线程的方法有两种(Thread Runnable)或三种(外加Callable Future),这种说法不能...

    从操作系统的角度来看,线程是CPU调度的最小单位——可以理解为一种资源、权利,即能够获得CPU的使用权

    网上很多文章中说java创建线程的方法有两种(Thread Runnable)或三种(外加Callable Future),这种说法不能说是错误的,但是很容易误导人,实际上,创建线程(拥有CPU使用权的线程)只有一种方法,那就是继承Thread类。实现Runnable(包括Callable Future)准确地说,不是线程,而是任务,站在操作系统的角度来看,一个类实现类Runnable,并没有立刻获得能够使用CPU的权利,来看一下Runnable和Thread的源码

    @FunctionalInterface
    public interface Runnable {
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }
    public class Thread implements Runnable {
        private ThreadGroup group;
    
        public synchronized void start() {
            if (threadStatus != 0)
                throw new IllegalThreadStateException();
    
            group.add(this);
    
            boolean started = false;
            try {
                start0();
                started = true;
            } finally {
                try {
                    if (!started) {
                        group.threadStartFailed(this);
                    }
                } catch (Throwable ignore) {
                }
            }
        }
    
        private native void start0();
    
        /**
         * If this thread was constructed using a separate
         * <code>Runnable</code> run object, then that
         * <code>Runnable</code> object's <code>run</code> method is called;
         * otherwise, this method does nothing and returns.
         * @see     #start()
         */
        @Override
        public void run() {
            if (target != null) {
                target.run();
            }
        }

    注释我去掉了一些,从Thread.run()方法来看,Runnable要是能运行的话——获得CPU的使用权,那么要放在Thread的构造函数中,否则不执行,然后看Thread.start()方法,其中调用了start0()方法,该方法是个本地方法,本地方法的实现要去看源码,openjdk8的源码下载地址,因为最终是要看cpp的,而我不会cpp,引用另外两篇博文:调用Thread.start()方法,JVM(Hotspot)会调用操作系统的API来创建一个操作系统线程,此时一个Java线程对象就与一个操作系统线程一一对应。

    那么为什么需要Runnable接口呢?只有Thread不就够类么,重写run()方法就行了,网上很多都说Runnable是接口,而Thread是类,实现Runnable能够避免Java单根继承带来的局限,且实现Runnable接口的方式创建的线程可以处理同一资源,从而实现资源的共享

    我认为都没说到点子上,重点是:调用Thread.start()时,是通过操作系统来创建线程的,而创建线程必然是运行在内核态,那么就一定有上下文切换,从而带来额外的时间和空间开销。如果将线程(Thread对象)看作插槽,它代表了资源——能够使用CPU(其实还有寄存器等存储资源),Runnable对象看作插头——要运行的任务,因为创建、撤销插槽开销很大,那么可以先创建一组插槽,什么任务需要运行,就插入相应的插头,就能够避免频繁的创建、撤销,避免上下文切换,从而提高性能,没错,就是线程池的思想

    很多地方的线程和任务并没有分清楚,比如这里,若是站在java程序员的角度,Runnable就是一个线程,为啥?我要在执行多个任务,实现Runnable接口,不就是线程么

    1.1实现Runnable接口

    public class MyRunnable{
    
        public static void main(String[] args) {
            Thread[] ths = new Thread[3];
            for (int i = 0; i < 3; i++) {
                ths[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int j = 0; j < 5; j++)
                            System.out.print(j);
                        System.out.print(" ");
                    }
                });
            }
            for (Thread th: ths)
                th.start();
        }
    }

    注意Runnable使用了匿名内部类,

    1.2继承自Thread类

    public class MyThread extends Thread{
        @Override
        public void run(){
            for (int i = 0; i < 5; i++)
                System.out.print(i);
            System.out.print(" ");
        }
    
        public static void main(String[] args){
            MyThread[] thx = {
                    new MyThread(),
                    new MyThread(),
                    new MyThread(),
            };
            for (MyThread th: thx){
                th.start();
            }
        }
    }

    需要注意的是,以上两个程序中,线程的启动顺序是确定的,但是执行顺序是不确定的,因为是并发执行而不是顺序执行的,JVM和操作系统一起决定了线程的执行顺序,下图分别为Runnable在windown7+jdk1.7.0_67和ubuntu16.04+jdk1.8.0_101上运行的结果

    **MyRunnableWindows**
    **MyRunnableUbuntu**

    参考资料:
    1. java编程思想
    2. http://www.ticmy.com/?p=230
    3. http://blog.csdn.net/jeffhtlee/article/details/12751825

    展开全文
  • 多线程:创建线程的方法 进程:进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。 线程:线程是进程中的一个执行单元,负责当前...

    多线程:创建线程的方法

    进程:进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。

    线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。

    简而言之:一个程序运行后至少有一个进程,一个进程中可以包含多个线程

    多线程:一个程序中有多个线程在同时执行。

     

     

    创建线程:

    方法1:继承Thread类。Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

      

    创建线程的步骤:

    1.定义一个类继承Thread。

    2.重写run方法。

    3.创建子类对象,就是创建线程对象。

    4.调用start方法,开启线程并让线程执行,同时还会告诉jvm去调用run方法

    例如:

    package com.itheima;
    
    public class MyThread extends Thread {
    	@Override
    	public void run() {
    		for (int i = 0; i < 100; i++) {
    			System.out.println(getName() + ":" + i);
    		}
    	}
    }
    package com.itheima_01;
    /*
     * 多线程的实现方式:
     * 		方式1:一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。
     *接下来可以分配并启动该子类的实例
     * 
     * Thread
     * 		String getName()      返回该线程的名称。 
     * 		void   setName(String name) 改变线程名称,使之与参数 name 相同。
     * 
     * 
     * CPU执行程序的随机性
     */
    
    
    public class ThreadDemo2 {
    	public static void main(String[] args) {
    
    		//创建线程实例
    		MyThread mt = new MyThread();
    
    		//修改线程名字
    		mt.setName("张三");
    		
    		//启动线程
    		mt.start();
    		
    		//创建线程实例
    		MyThread mt2 = new MyThread();
    		mt2.setName("老王");
    		
    		//启动线程
    		mt2.start();
    	}
    }

    方法2:实现Runnable接口

    创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象,传入到某个线程的构造方法中,开启线程。

    Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法,需要由接口实现类重写该方法。

    创建线程的步骤:

    1、定义类实现Runnable接口。

    2、覆盖接口中的run方法。。

    3、创建Thread类的对象

    4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

    5、调用Thread类的start方法开启线程。

    例如:

    package com.itheima;
    
    public class MyThread2 implements Runnable {
    	int num;
    	
    	public MyThread2(int num) {
    		this.num = num;
    	}
    	
    	@Override
    	public void run() {
    		for (int i = 0; i < 100; i++) {
    
    			//Thread t = Thread.currentThread();
    			//System.out.println(t.getName() + ":" + i);
    			
    			//链式编程
    			System.out.println(Thread.currentThread().getName() + ":" + i + num);
    		}
    	}
    
    }
    package com.itheima;
    
    public class ThreadDemo2 {
    	public static void main(String[] args) {
    		//创建线程实例
    		MyThread2 mt = new MyThread2();
    		Thread t = new Thread(mt);
    		t.setName("李四");
    		//启动线程
    		t.start();
    		
    		//创建线程实例
    		MyThread2 mt2 = new MyThread2();
    		Thread t2 =  new Thread(mt2);
    		t2.setName("老王");
    		//启动线程
    		t2.start();
    		}
    }
    

     

    展开全文
  • 创建线程的两种方法

    千次阅读 2016-05-30 16:07:35
    创建线程的方法有两种方法 1.利用Thread类的子类来创建线程 2.利用Runnable接口来创建线程 Thread类的构造方法有: public Thread(); //使用这个构造方法必须创造一个子类,并且覆盖run()方法 public ...

    创建线程的方法有两种方法

    1.利用Thread类的子类来创建线程

    2.利用Runnable接口来创建线程



    Thread类的构造方法有:

    public Thread();   //使用这个构造方法必须创造一个子类,并且覆盖run()方法

    public Thread(String name);//name是指定线程的名字

    public Thread(Runnable target);  //target的run()方法将被线程对象调用

    public Thread(Runnable target,String name) //不仅target的run()方法将被线程调用,而且线程的名字也将被name指定



    Thread类里的常用方法

    public static Thread currentThread();//返回当前正在运行的线程对象

    public final String getName();//返回线程的名字

    public void start();//将线程由新建状态变为就绪状态

    public void run();//线程执行的任务

    public final boolean isAlive();//当前的线程是否在运行,是就返回true,不是就返回false

    public static boolean isInterrupted();//判断线程是否被中断,是就返回true,不是就返回false

    public final void join();//暂停当前线程的运行,直到调用该方法的线程运行结束在继续运行

    public final int getPriority();//返回线程的优先级

    public final void setPriority(int newPriority)// 设置线程的优先级

    public static void sleep(long millis);//为当前线程指定睡眠时间

    public static void yield();//暂停当前线程的运行,但是该线程仍然处于就绪状态,不转为阻塞状态,该方法只给同优先级线程以运行的机会



    Thread类创建线程的步骤:

    1.子类继承Thread类

    2.线程所要执行的代码都写在run()方法内


    package practice4;




    class MyThread1 extends Thread{
    private String who;
    public MyThread1(String str){
    who=str;
    }
    public void run(){
    for(int i=0;i<5;i++){
    try {
    sleep((int)(1000*Math.random()));
    } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    System.out.println(who+i+"正在运行!!!");
    }

    }
    }

    public class App11_1 {


    public static void main(String[] args) {
    // TODO Auto-generated method stub
    MyThread1 you=new MyThread1("你");
    MyThread1 she=new MyThread1("她");
    you.start();
    try {
    you.join();
    } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    she.start();
    try {
    she.join();
    } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    System.out.println("主方法main()运行结束!!!");
    }

    }




    Runnable接口中只有一个方法run(),用户可以声明一个类并实现Runnable接口,然后重新定义run()方法,将线程代码写入其中,就完成了这一部分的任务。但是Runnable接口并没有任何对线程的支持,还必须创建Thread的实例,可以通过Thread的构造方法来实现


    package practice4;
    class MyThread implements Runnable{
    private String who;
    public MyThread(String str){
    who=str;
    }
    public void run(){
    for(int i=0;i<5;i++){
    try {
    Thread.sleep((int)(1000*Math.random()));
    } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    System.out.println(who+"正在运行!!");
    }
    }
    }




    public class App11_2 {



    public static void main(String[] args) {
    // TODO Auto-generated method stub
    MyThread you =new MyThread("你");
    MyThread she =new MyThread("她");
    Thread t1=new Thread(you);
    Thread t2=new Thread(she);
    t1.start();
    t2.start();
    }


    }




    两种创建线程的方式的特点:

    直接继承Thread类的特点:编写简单,可以直接操作线程,缺点是一当继承了Thread类,则既不能继承其他的类

    Runnable接口的特点是:可以将Thread和要处理的任务的类分开,形成清晰的模型。在Thread类中的this即指当前进程,而在Runnable接口中,只能通过Thread.currentThread()方法。

    展开全文
  • java创建线程的方法有两种: 实现Runnable接口 继承Thread类;
  • Java 创建线程的方法

    2013-01-29 19:08:55
    1、Thread类的构造方法有8个,但常用的只有4个,分别为:    Thread类中的两个最主要的方法:  (1)run()—包含线程运行时所执行的代码,即线程需要完成的任务,是线程执行体。  (2)start
  • 创建线程的方法2

    2011-11-10 14:00:14
    实现Runnable接口的类 覆盖其中的run方法 通过thread类建立线程对象 ...继承了Thread类则不能继承其他的类,如果一个类即继承了其他的类其中又的代码需要多线程去执行,这种情况下就需要第二种创建线程的方法
  • 其实,创建线程与创建普通对象操作是一样,而线程就是Thread类或其子类实例对象。每个Thread对象描述了一个单独线程。要产生一个线程,两种方法: ◆需要从Java.lang.Thread类派生一个新线程类...
  • 如何创建线程创建线程有几种方法?怎么实现
  • C++利用API接口createthread创建线程和利用库thread创建线程有什么具体区别,希望具体点(什么时候用哪种)。
  • 创建线程的三种方法

    2018-02-27 21:32:34
    今天面试被面试官问到如何让线程的方法体拥有返回值。以前学习了解的时候只知道两种创建方法,顿时就被问住了,回来马上充电学习了下。这里顺便总结一下。java中创建线程的三种方法以及区别Java使用Thread类代表...
  • 在Java中创建线程有两种方法:使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此,无论是通过Thread类还是Runnable接口建立线程,都必须建立Thread类或它子类实例。Thread类...
  • java创建线程的方法

    2020-06-13 20:35:43
    java 中创建线程的方法主要四种方式,下面我简述这四种方法。 匿名内部类创建对象,重写run()方法 package part11; import java.util.concurrent.TimeUnit; public class Demo { public static void main...
  • 在子线程中创建线程的方法

    千次阅读 2006-11-22 10:29:00
    与在主线程创建线程的方法是一样的----Windows95是Microsoft公司的第一个真正的多任务操作系统。在每一时刻可以多个进程同时工作,而每一个进程又包含多个线程。但只有一个处理器的计算机不可能真正地“同时”...
  •  Java提供了线程类Thread来...其实,创建线程与创建普通对象操作是一样,而线程就是Thread类或其子类实例对象。每个Thread对象描述了一个单独线程。要产生一个线程,两种方法:  ◆需要从Java.l
  • 在子线程中创建线程的方法

    万次阅读 2006-04-21 09:39:00
    与在主线程创建线程的方法是一样的重庆邮电学院计算机系综合微机室马英杰----Windows95是Microsoft公司的第一个真正的多任务操作系统。在每一时刻可以多个进程同时工作,而每一个进程又包含多个线程。但只有一...
  • Java中创建线程主要三种方式: 一、继承Thread类创建线程类 (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 (2)创建Thread...
  • 其实,创建线程与创建普通对象操作是一样,而线程就是Thread类或其子类实例对象。每个Thread对象描述了一个单独线程。要产生一个线程,两种方法: ◆需要从Java.lang.Thread类派生一个新线程类...
  • 一、继承Thread类创建线程类 (1) 定义一个类并继承Thread,重写run方法,该run方法为该线程需要完成的任务,及线程的执行体。 (2) 创建该类的实例对象,及为创建了线程对象。 (3) 调用线程的start方法,及启动...
  • java创建线程的两种方法本人小白一枚,初学java。感觉java学起来非常自然,写起程序来思路也很清晰,刚刚学完多线程编程一块,所以想将一些比较重点的知识点写下来,防止遗忘。java中创建一个线程两种方法: 继承...
  • 2, 实现Runnable接口,再通过Thread类创建线程,并将事先了Runnable接口子类对象作为参数传递给Thread类构造函数。使用匿名内部类来写。 方法一源码: class ThreadDemo extends Thread{  private
  • 线程的创建和结束的方法

    千次阅读 2008-09-25 18:06:00
    创建线程的方法有两种:一种是使用WinAPI中的CreateThread, 另一中是使用MFC的AfxBeginThread 1、使用WinAPIWINBASEAPIHANDLEWINAPICreateThread( IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN SIZE_T ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,845
精华内容 6,738
关键字:

创建线程的方法有