精华内容
下载资源
问答
  • 创建单线程的方法有两种 (1)继承thread类 用start方法启动线程 (2)实现Runnable接口 用start方法启动线程 创建线程池

    创建单线程的方法有两种
    (1)继承thread类
    用start方法启动线程
    (2)实现Runnable接口
    用start方法启动线程

    创建线程池

    展开全文
  • 创建单线程有3种方法,分别为: 1、继承 Thread 2、实现 Runable 接口 3、实现 Callable 接口,实现接口call()方法,通过FutureTask可以获取到线程执行完成之后返回结果 代码如下: import java.util....

    创建单线程有3种方法,分别为:

    1、继承 Thread

    2、实现 Runable 接口

    3、实现 Callable 接口,实现接口的call()方法,通过FutureTask可以获取到线程执行完成之后返回的结果

    代码如下:

    
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    
    
    public class SoureThread {
    	public static void main(String[] args) {
    		
    		new threadTest().start() ;
    		
    		new Thread(new Runable()).start();
    		
    		FutureTask<Object> futureTask = new FutureTask<Object>(new callAble());
    		
    		new Thread(futureTask,"12").start();
    		
    		try {
    			System.out.println(futureTask.get());
    		} catch (InterruptedException | ExecutionException e) {
    			e.printStackTrace();
    		}
    		
    	}
    }
    class threadTest extends Thread {
    	@Override
    	public void run() {
    		super.run();
    		System.out.println("SoureThread.threadTest.run()");
    	}
    }
    
    class Runable implements Runnable {
    	@Override
    	public void run() {
    		System.out.println("SoureThread.Runable.run()");
    	}
    }
    
    class callAble implements Callable<Object>{
    	@Override
    	public Object call() throws Exception {
    		return 1;
    	}
    }
    

    通过继承Thread和实现Runable接口都可以创建一个线程,区别主要在于:

    实现Runable的同时还可以继承其他类,而继承了Thread就不能再进行多继承。

    展开全文
  • 目录创建线程的6种方法继承 Thread 类第一种第二种实现 Runnable 接口第三种第四种第五种实现 Callable 接口第六种单线程 VS 多线程 创建线程的6种方法 继承 Thread 类 第一种 /* 继承Thread类 */ public class ...

    创建线程的7种方法

    继承 Thread 类

    第一种

    /*
        继承Thread类
     */
    public class ThreadDemo1 {
        static class MyThread extends Thread {
            @Override
            public void run() {
                //线程执行任务
                System.out.println("当前线程名称:" + Thread.currentThread().getName());
            }
        }
        public static void main(String[] args) {
            //创建线程
            Thread t1 = new MyThread();
            //运行线程
            t1.start();
    
            System.out.println("主线程名称:" + Thread.currentThread().getName());
        }
    }
    
    
    //执行结果
    主线程名称:main
    当前线程名称:Thread-0
    

    第二种

    public class ThreadDemo2 {
        public static void main(String[] args) {
            Thread thread = new Thread(){
                @Override
                public void run() {
                    System.out.println("当前线程名称:" + Thread.currentThread().getName());
                }
            };
    
            //执行线程
            thread.start();
        }
    }
    
    //执行结果
    当前线程名称:Thread-0
    

    实现 Runnable 接口

    第三种

    public class ThreadDemo3 {
        static class MyRunnable implements Runnable {
            @Override
            public void run() {
                System.out.println("当前线程名称:" + Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) {
            //新建Runnable
            MyRunnable runnable = new MyRunnable();
            //创建线程
            Thread thread = new Thread(runnable);
            //启动线程
            thread.start();
        }
    }
    
    
    //执行结果
    当前线程名称:Thread-0
    

    第四种

    //最主流的写法
    public class ThreadDemo4 {
        public static void main(String[] args) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("当前线程名称:" + Thread.currentThread().getName());
                }
            });
    
            //启动线程
            thread.start();
        }
    }
    
    
    //执行结果
    当前线程名称:Thread-0
    

    第五种

    public class ThreadDemo5 {
        public static void main(String[] args) {
            //lambda + 匿名 Runnable 的方法  (JDK 8 后版本可使用此方法)
            Thread thread = new Thread(()->{
                System.out.println("当前线程名称:" + Thread.currentThread().getName());
            });
    
            thread.start();
        }
    }
    
    //执行结果
    当前线程名称:Thread-0
    

    第六种

    public class ThreadDemo5 {
        public static void main(String[] args) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("当前线程名称:" + Thread.currentThread().getName());
                }
            };
    
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }
    
    //执行结果
    当前线程名称:Thread-0
    

    实现 Callable 接口

    第七种

    import java.util.Random;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.Future;
    import java.util.concurrent.FutureTask;
    
    /*
        创建并得到线程的执行结果
        实现 Callable 接口 + Future 的方式
     */
    public class ThreadDemo6 {
        //创建了线程的任务
        static class MyCallable implements Callable<Integer> {
    
            @Override
            public Integer call() throws Exception {
                //生成一个随机数
                int num = new Random().nextInt(10);
                System.out.println("子线程:" + Thread.currentThread().getName() + ",随机数:" + num);
                return num;
            };
        }
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //创建 Callable
            MyCallable callable = new MyCallable();
    
            //创建 FutureTask 对象接收返回值
            FutureTask<Integer> future = new FutureTask<>(callable);
    
            //创建Thread
            Thread thread = new Thread(future);
    
            //执行线程
            thread.start();
    
            int result = future.get();
    
            System.out.println(String.format("线程名:%s,数字:%d",Thread.currentThread().getName(),result));
    
        }
    }
    
    //执行结果
    子线程:Thread-0,随机数:6
    线程名:main,数字:6
    

    单线程 VS 多线程

    public class ThreadText {
        public static final Long count = 5_0000_0000L;
        public static void main(String[] args) {
    
            //调用多线程的方法
            concorrency();
    
            //调用单线程的执行方法
            single();
        }
    
        //单线程的方法
        private static void single() {
            //开始时间
            Long sTime = System.currentTimeMillis();
    
            int a = 0;
            for (int i = 0; i < 3 * count; i++) {
                a++;
            }
    
            //结束时间
            Long eTime = System.currentTimeMillis();
            System.out.println("单线程的执行时间:" + (eTime - sTime));
        }
    
        //多线程的方法
        private static void concorrency() {
    
    
            //开始时间
            Long sTime = System.currentTimeMillis();
    
            //创建线程任务1
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    int a = 0;
                    for (int i = 0; i < count; i++) {
                        a++;
                    }
                }
            });
    
            //开始执行线程1
            t1.start();
    
            //创建线程任务2
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    int b = 0;
                    for (int i = 0; i < count; i++) {
                        b++;
                    }
                }
            });
            //开始执行线程2
            t2.start();
    
            //主线程执行
            int c = 0;
            for (int i = 0; i < count; i++) {
                c++;
            }
    
    
            //结束时间
            Long eTime = System.currentTimeMillis();
            //结果
            System.out.println("多线程执行时间:" + (eTime - sTime));
        }
    }
    
    //执行结果
    多线程执行时间:332
    单线程的执行时间:899
    
    展开全文
  • 文章目录认识线程概念线程的创建方式线程的第一种创建方式线程的第二种创建方式线程的第三种创建方式线程的第四种创建方式线程的创建速度单线程的创建速度多线程的创建速度 认识线程 概念 进程是系统分配资源的最小...

    认识线程

    概念

    • 进程是系统分配资源的最小单位,线程是系统调度的最小单位。
    • 一个进程内的线程之间是可以共享资源的。
    • 每个进程至少有一个线程存在,即主线程。
      在这里插入图片描述

    线程的创建方式

    线程的第一种创建方式

    可以通过继承 Thread 来创建一个线程类

    public class ThreadDemo1 {
    
        //第一种线程创建方法
        static class  MyThread extends Thread{
            @Override
            public void run(){
                System.out.println("我是线程1");
                //获取到当前线程 并设置线程名
                Thread.currentThread().setName("我是自己创建的线程");
                try {
                    Thread.sleep(180*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public static void main(String[] args) {
            MyThread thread=new MyThread();
            thread.start();
        }
    }
    
    

    该方法的好处是 this 代表的就是当前线程,不需要通过
    Thread.currentThread() 来获取当前线程的引用。

    线程的第二种创建方式

    通过实现 Runnable 接口,并且调用 Thread 的构造方法时将 Runnable 对象作为 target 参数传入来创建线程对象。

    public class ThreadDemo2 {
        static class MyThread2 implements Runnable{
            @Override
            public void run(){
                System.out.println("我是线程2:"+Thread.currentThread().getName());
    
            }
            public static void main(String[] args) {
                Thread thread=new Thread(new MyThread2());
                thread.start();
            }
        }
    }
    

    该方法的好处是可以规避类的单继承的限制;但需要通过 Thread.currentThread() 来获取当前线程的引用。

    线程的第三种创建方式

    第三种创建方式(lambda表达式)个人推荐

    public class ThreadDemo3 {
    
        public static void main(String[] args) {
            Thread thread=new Thread(()->{
                System.out.println("我是线程3:"+Thread.currentThread().getName());
    
            });
            thread.start();
        }
    }
    

    线程的第四种创建方式

    public class ThreadDemo4 {
    
        public static void main(String[] args) {
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("我是线程:"+Thread.currentThread().getName());
                }
            });
            thread.start();
        }
    }
    

    后两种可做了解。

    线程的创建速度

    单线程的创建速度

    public class ThreadDemo5 {
        public static int  count=10_1000_0000;
    
        public static void main(String[] args) {
            //开始时间
            long startTime =System.nanoTime();
    
            int i=0;
            int k=0;
            for (int j=0;j<count;j++){
                i++;
            }
            for (int j=0;j<count;j++){
                k++;
            }
            //结束时间
            long endTime=System.nanoTime();
            System.out.println("执行时间:"+(endTime-startTime));
        }
    
    }
    

    在这里插入图片描述
    在这里插入图片描述

    多线程的创建速度

    public class ThreadDemo6 {
        public static int  count=10_1000_0000;
    
    
        public static void main(String[] args) throws InterruptedException {
    
            Thread t1=new Thread(()->{
                int i=0;
                for (int j=0;j<count;j++){
                    i++;
                }
            });
    
            Thread t2=new Thread(()->{
                int k=0;
                for (int j=0;j<count;j++){
                    k++;
                }
            });
            long startTime=System.nanoTime();
            t1.start();
            t2.start();
            //等待线程执行完
            t1.join();
            t2.join();
            long endTime=System.nanoTime();
            System.out.println("执行时间:"+(endTime-startTime));
        }
    }
    
    

    在这里插入图片描述
    在这里插入图片描述
    通过运行结果的对比 可以发现时间上的差别

    展开全文
  • Java 创建线程的两个方法Java提供了线程类Thread来创建线程的程序。其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个...
  •  Java提供了线程类Thread来创建线程的程序。其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程,有两种方法:  ...
  • Java提供了线程类Thread来创建线程的程序。其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程,有两种方法:◆需要...
  • 原始的创建线程的方法有三种,分别是:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口。当然还可以利用Future和FutureTask来获取返回值。
  • 创建线程的方法

    2016-09-23 09:01:00
    创建线程有2种方法1继承Thread类, 该子类应重写 Thread类的 run 方法2实现Runnable接口,将类声明为 ...接下来可以分配并启动该子类的实例创建线程的步骤: 1 定义一个类继承Thread。 2 重写run方法。 3 创建子类...
  • 多线程:创建线程的方法 进程:进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。 线程:线程是进程中的一个执行单元,负责当前...
  • Java提供了线程类Thread来创建线程的程序。其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程,有两种方法:◆需要...
  • /*进程:是一个正在执行中程序每一个进程执行都有执行顺序,该顺序是一个执行路径...这个线程运行代码存在于main方法中,该线程称之为主线程JVM启动不止一个线程,还有复制垃圾回收机制的线程创建线程:(1)继承T...
  • 1. 什么是并发与并行要想...进程是线程的容器,即一个进程中可以开启多个线程。比如打开一个浏览器、打开一个word等操作,都会创建进程。线程:线程是进程内部的一个独立执行单元;一个进程可以同时并发运行多个线程...
  • VC启动一个新线程的三种方法,有需要的朋友可以参考下。 第一种AfxBeginThread() 用AfxBeginThread()函数来创建一个新线程来执行任务,工作者线程的AfxBeginThread的原型如下: CWinThread* AfxBeginThread(AFX_...
  • 文章目录创建线程的四种方式区别示例 创建线程的四种方式 1:继承Thread类创建线程 2:实现Runnable接口创建线程 3:使用Callable和FutureTask创建线程 4:使用线程池,例如用Executor框架创建线程 区别 1、...
  • 1,线程和进程的基本概念: 进程是操作系统结构的基础,是程序在一个数据集和上运行的过程,它是系统进行资源分配和调度的一个独立单位。 线程是进程的组成部分,是...2,线程的两种创建方式以及启动 第一种,继承Thr
  • Java提供了线程类Thread来创建线程的程序。其实,创建线程与创建普通的类的对象的操作是一样的,而线程是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程,有两种方法:  ◆...
  • 要产生一个线程,有两种方法:◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法...这样,如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的,那么这个自定义类就不能再去扩展其他的类...
  • java中提供了线程类Thread,每个Thread类对象描述了一个单独的线程。但是,要产生一个线程有两种方法:1,需要从Java.lang.Thread类派生一个新的线程类,重载它...也就是说创建自定义线程时候是通过extends ...
  • Java提供了线程类Thread来创建线程的程序。其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程,有两种方法: ◆...
  • 创建自定义线程的两种方法 方式1: ​ 自定义线程类,继承Thread类,重写run方法 方式2: ​ 自定义线程类,遵循Runnable接口。实现run方法 使用接口的方式 ​ 只能是继承的,如果继承了Thread类之后,你再...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,058
精华内容 1,623
关键字:

创建单线程的方法