Java并发编程-创建线程的两种方式及区别

转载请注明:http://blog.csdn.net/UniKylin/article/details/45016117

1.线程和进程的区别

并行:是多个任务在同一时间同时执行,例如多核计算机同时计算的任务可以理解为并行

并发:从微观上看是多个任务抢占一个CPU从而执行自己的任务,轮流执行任务,但是如果遇到资源冲突的时候并没有从根本提高执行效率。但是提高了CPU的使用效率。

前段时间在GitHub上的一幅图可以很好的阐述上面的概念非常形象

2.Java中创建线程的两种方式

1.第一种方式:直接继承Thread:

public class Dog extends Thread {
    // 私有变量
    private int number;

    // 初始化乘法表上限数字
    public Dog(int number) {
        this.number = number;
    }

    //重写逻辑方法
    @Override
    public void run() {
        // 打印乘法表
        for (int i = 1; i <= number; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " * " + i + " = " + i * j + "\t");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        Dog dog = new Dog(9);
        dog.start();//启动线程打印乘法表
    }
}

2.第二种方式:实现Runnable接口的方式

public class Cat implements Runnable {

    private int number;

    public Cat(int number) {
        this.number = number;
    }

    //重写逻辑方法
    @Override
    public void run() {
        System.out.println("Current Thread :" + Thread.currentThread());
        for (int i = 0; i <= number; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(i + " * " + j + " = " + i * j + "\t");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Thread task = new Thread(new Cat(9));
        task.start();
    }
}

对比以上两种方式可以发现:第一种方式继承Thread不能再继承其他父类,所以对于程序的扩展性不是很友好,但是可以通过this访问当前线程的信息。第二种方式继承Runnable接口,从设计角度来看比较灵活,Java是不支持多继承但是支持实现多个接口,这样就可以将这个缺点给克服了,如果要访问线程信息需要使用Thread.currentThread();方法。

3.源码分析

public class Thread implements Runnable {
    //关联Runnable接口
    private Runnable target;

    //线程逻辑方法
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

//线程接口
public interface Runnable {
    //定义抽象的线程逻辑方法,
    public abstract void run();
}

上面的Thread类和Runnable接口是Java JDK中两个最重要的核心部分,继承Thread属于对JDK本身的系统类的扩展,而实现Runnable接口的方式属于实现一种标准。不管哪种方式JVM启动线程的过程中都将他们进行装载,只不过方式不一样而已。具体哪种方法比较好,当然第二种方式从设计方面比较优雅和灵活。

时间: 2024-12-26 13:00:20

Java并发编程-创建线程的两种方式及区别的相关文章

【java并发】传统线程技术中创建线程的两种方式

传统的线程技术中有两种创建线程的方式:一是继承Thread类,并重写run()方法:二是实现Runnable接口,覆盖接口中的run()方法,并把Runnable接口的实现扔给Thread.这两种方式大部分人可能都知道,但是为什么这样玩就可以呢?下面我们来详细分析一下这两种方法的来龙去脉. 1. 揭秘Thread中run()方法 上面我们看到这两种方式都跟run()方法有关,所以我们来看一下Thread的源码中run()方法到底都干了什么: @Override public void run()

创建线程的两种方式比较Thread VS Runnable

1.首先来说说创建线程的两种方式 一种方式是继承Thread类,并重写run()方法 1 public class MyThread extends Thread{ 2 @Override 3 public void run() { 4 // TODO Auto-generated method stub 5 6 } 7 } 8 //线程使用 9 MyThread mt = new MyThread(); //创建线程 10 mt.start(); //启动线程 另外一种方式是实现Runnabl

黑马程序员——创建线程的两种方式

java中创建线程有两种方式: 1.继承Thread类 步骤: (1)定义一个类继承Thread类 (2)复写Thread类中的run()方法 (3)调用start()方法:启动线程及调用run()方法 2.实现Runnable接口的方式 步骤:(1)定义一个类实现Runnable接口 (2)覆盖Runnable接口中的run()方法,将线程要运行的代码放到该run方法中 (3)通过Thread类建立线程对象 (4)将实现Runable接口的类对象作为实际参数传递给Thread的构造函数. (5

创建线程的两种方式

首先我们需要知道什么是线程:是程序执行流的最小单元,包括就绪.阻塞和运行三种基本状态. 举个简单的例子:我们把生活中的两件事吃饭和写作业当作是两个线程,当你正在写作业的时候,爸妈叫你吃饭,你就直接去了,等吃完饭回来后再接着写作业.这就是相当于两个线程其中一个从运行状态转入就绪状态,另一个线程从就绪状态转入运行状态. 创建线程包括继承Thread类和实现Runnable接口两种方式(JDK5.0以后还包括了实现Callable等方式来实现线程,这里不做介绍,感兴趣的小伙伴可以自己查资料),下面介绍

JAVA中创建字符串的两种方式的区别

我们知道,通常在Java中创建一个字符串会有两种方式,通过双引号直接赋值和通过构造器来创建. String x = "abcd"; String y = new String("abcd"); 然而,这两种方式之间的区别是什么?分别应用于哪些情况,之前还不是很懂. 1.双引号的方式 String x = "abcd"; String y = "abcd"; System.out.println(x==y);//true Sys

Java并发编程(一) 两种实现多线程的方法(Thread,Runnable)

Java中实现多线程的方法有两种: 继承Thread类和实现Runnable方法,并重写Run方法,然后调用start()方法启动线程.使用Runnable会比Thread要好很多,主要是以下三个原因: (1)Java语言是单继承的,如果继承了Thread类,那么便无法继承其他类. (2)适合多个相同程序代码的线程区处理同一资源的情况. 测试(Thread类) package com.csdhsm.concurrent; /** * @Title: ThreadDemo.java * @Pack

《多线程编程》——创建线程的两种方式

1.目的 创建线程,即拿到一个线程实例.这个线程实例必须具备开启.等待.唤醒等控制自身生命周期的方法. 2.创建Thread线程 方式一:new Thread().new Thread(String name) 1 /** 2 *两个构造器也有区别:线程名不同 3 */ 4 public class Thread implements Runnable { 5 private char name[]; 6 7 //1.不带参 8 /* 9 *Automatically generated nam

Java多线程——创建线程的两种方式

创建线程方式一:继承Thread类. 步骤:1,定义一个类继承Thread类.2,覆盖Thread类中的run方法.3,直接创建Thread的子类对象创建线程.4,调用start方法开启线程并调用线程的任务run方法执行. 可以通过Thread的getName获取线程的名称 Thread-编号(从0开始)主线程的名字就是main. 例: class Demo extends Thread { private String name; Demo(String name) { super(name)

Java创建线程的两种方式

方式 继承Thread类 实现Runnable方法 实例 #继承Thread类 public class ThreadTest2 extends Thread { private int threadCnt = 10; @Override public void run() { while (true) { if (threadCnt > 0) { System.out.println(Thread.currentThread().getName() + " 剩余个数 " + t