2018-08-25多线程Thread类+Runnable接口+线程的6种状态

多线程：

进程：进程指正在运行的程序；确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能（进入内存运行的程序成为进程）！

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程！一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序（线程是执行单元，一个进程可以包括多个线程，一个程序可以有多个进程）！

单线程程序：若有多个任务只能依次执行（这个任务执行完毕，下一个任务开始执行）！如：去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网（这个任务进站执行完毕，弹栈之后，下一个任务才可以执行）！

多线程程序：若有多个任务可以同时执行！如：去网吧上网，网吧能够让多个人同时上网（一个线程建一个栈，多个栈内的任务同时执行，Main方法也是一个栈）！

//八核十六线程的CPU：一个核心有16个线程！

程序运行原理：

分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间（比如360安全卫士有3个功能：杀毒，电脑清理，系统修复，这三个功能会被JVM分配1微秒的时间片，轮流执行1微秒，看起来像是同时执行，但实际并不是）！

抢占式调度：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个（称为线程的随机性），Java使用的为抢占式调度（Java采用抢占式调度）！

//可以通过Windwos系统的任务管理器（Ctrl键+Shift键+Esc键调出）设置进程的优先级：

实际上，CPU（中央处理器）使用抢占式调度模式在多个线程间进行着高速的切换（分配时间片）！对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行，其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高（单核单线程只能这个任务执行完毕再执行下一个任务，现在多核多线程可以多个任务同时执行，节省时间）！

主线程：Main方法就是主线程！

JVM启动后必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在Java中称之为主线程！当程序的主线程执行时，如果遇到了循环而导致程序在指定位置停留时间过长，则无法马上执行下面的程序，需要等待循环结束后能够执行！

Thread类：

//第2个构造方法的String name是用来指定线程的名称！

常用方法：

//start()方法会调用继承自Thread类的子类重写之后的run()方法（如果直接使用Thread子类的对象调用重写后的run()方法，不会开启线程，就是普通的对象调用方法，所以想要开启线程用start()方法）！

//sleep()方法：让该线程休眠，即结束进程！

强调：

Thread t1 = new Thread();

t1.start();

//这样做没有错，但是该start()调用的是Thread类中的run()方法，而这个run()方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码！

每一个线程都有一个独立的内存中的栈空间，所以可以实现并发执行（又要牵扯到管理高并发的问题）：

当执行线程的任务结束了，线程自动在栈内存中释放了，但是当所有的执行线程都结束了，那么进程就结束了！

//获取当前执行的线程的对象或名称：

//由于这个方法是静态的，所以可以类名.方法调用！

课堂示例代码：

package com.oracle.duoxiancheng;
public class Demo01 {
    public static void main(String[] args) {
        //thread新建的线程，和Main方法都是线程，Main方法是主线程，在内存中享有独立的栈空间：
        //新建第一个线程：
        MyThread mt1=new MyThread();
        //开启该线程(调用run()方法)：
        mt1.start();
        //新建第二一个线程：
        MyThread mt2=new MyThread();
        //开启该线程(调用run()方法)：
        mt2.start();
        for(int i=0;i<1000;++i){
            System.out.println("main……"+i);
        }
        System.out.println("程序结束了！");
        //查看main方法线程名字：
        System.out.println(Thread.currentThread().getName());
    }
}

package com.oracle.duoxiancheng;
public class MyThread extends Thread {
    public void run() {
        System.out.println(super.getName());
        //重写run方法，把并发执行的代码放在里面，run方法不需要程序员调用，线程对象的.start()方法：
        for(int j=0;j<1000;++j){
            System.out.println("run……"+j);
        }
    }
}

创建线程方式—实现Runnable接口：

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

//好处：把任务体（Runnable中的run()方法）跟创建线程和开启线程（Thread和start()方法）分离开了！

Thread类的构造方法：

//可以传入一个Runnable对象，以及一个线程名字！

创建线程的步骤：

1；定义类实现Runnable接口！

2；覆盖接口中的run方法！

3；创建Thread类的对象！

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

5；调用Thread类的start()方法开启线程！

通过Runnable和Thread方法 来实现创建开启线程的好处：

①    实现Runnable接口，避免了继承Thread类的单继承局限性！覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中！

②    更加符合面向对象思想，实现了线程任务和线程对象的解耦！

//下方TIMED_WAITING应该是WAITING，其中Wait()和Notify()是属于Object类！

示例代码：

package com.oracle.duoxiancheng;
public class Demo01 {
    public static void main(String[] args) {
        //thread新建的线程，和Main方法都是线程，Main方法是主线程，在内存中享有独立的栈空间：
        //新建第一个线程，设置线程名称方法②，MyThread重写了Thread的构造方法：
        MyThread mt1=new MyThread("诸葛鬼才");
        //开启该线程(调用run()方法)：
        mt1.start();
        //新建第二一个线程：
        MyThread mt2=new MyThread();
        //设置线程名称方法①：
        mt2.setName("蔡文姬");
        //开启该线程(调用run()方法)：
        mt2.start();
        /*for(int i=0;i<1000;++i){
            System.out.println("main……"+i);
        }*/
        System.out.println("程序结束了！");
        //查看main方法线程名字：
        System.out.println(Thread.currentThread().getName());
    }
}

package com.oracle.duoxiancheng;
public class MyThread extends Thread {
    public MyThread(String getName){
        super(getName);
    }
    public MyThread(){

    }
    public void run() {
        System.out.println(super.getName());
        //重写run方法，把并发执行的代码放在里面，run方法不需要程序员调用，线程对象的.start()方法：
        /*for(int j=0;j<1000;++j){
            System.out.println("run……"+j);
        }*/
    }
}

通过Runnable接口和Thread对象开启线程：
package com.oracle.duoxiancheng;
public class Demo02 {
    public static void main(String[] args) throws InterruptedException {
        //runnable实现类任务的编写：
        MyRunnable mr=new MyRunnable();
        //Thread负责创建线程并开启线程
        Thread th1=new Thread(mr);
        th1.start();
        for(int i=0;i<50;++i){
            //休眠可以自己醒：
            Thread.sleep(5000);
            System.out.println("main……"+i);
        }
    }
}

package com.oracle.duoxiancheng;
public class MyRunnable implements Runnable {
    public void run(){
        for(int i=0;i<50;++i){
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("这个是run()方法内的……"+i);
        }
    }
}

匿名对象创建并开启线程：
package com.oracle.duoxiancheng;
public class Demo03 {
    public static void main(String[] args) {
        //匿名内部类，下面的new Thread是Thread的子类，只不过没有名字：
        new Thread(){
            public void run(){
                for(int i=0;i<50;++i){
                    System.out.println("Run……"+i);
                }
            }
        }.start();

        //匿名内部类，匿名new Thread对象里面放一个匿名内部类（Runnable的子类）：
        new Thread(new Runnable(){
            public void run(){
                for(int i=0;i<50;++i){
                    System.out.println("Run……"+i);
                }
            }
        }).start();

        //匿名内部类，new Runnable(){}部分是Runable的子类，前面的Runnable ra=是多态，传入Thread子类对象的构造方法：
        Runnable ra=new Runnable(){
            public void run(){
                for(int i=0;i<50;++i){
                    System.out.println("Run……"+i);
                }
            }
        };
        Thread ta=new Thread(ra);
    }
}

原文地址：https://www.cnblogs.com/postgredingdangniu/p/9534519.html

时间： 2024-10-05 05:11:55

2018-08-25多线程Thread类+Runnable接口+线程的6种状态的相关文章

探Java多线程Thread类和Runnable接口之间的联系

首先复习一下Java多线程实现机制,Java实现多线程方法有如下这么几种: 1.继承了(extends)Thread类 2.实现了(implements)Runnable接口 也就是说  有如下两种情况 情况1: 继承Thread类.重写其方法run() .    然后new之.调用Start()方法 1 public class TestThread 2 { 3 private int i; 4 public static void main(String[] args) 5 { 6 // T

多线程之实现Runnable接口及其优点

多线程之实现Runnable接口: 1.创建一个Runnable接口的实现类 2.在实现类中重写Runnable接口的run方法 3.创建一个Runnable接口实现类的对象 4.创建Thread类对象,构造方法中传参为:Runnable接口实现类的对象 5.调用Thread类中的start方法,启动多线程 打印结果(并发): 实现Runnable接口创建多线程与继承Thread类相比优点是: 1.避免了继承Thread类的单继承的局限性.[类只能单继承,类继承了Thread类就不能继承其他的类

2.匿名类，匿名类对象，private/protected/public关键字、abstract抽象类，抽象方法、final关键字的使用，多线程Thread类start方法原理

package com.bawei.multithread; //注意:模板方法我们通常使用抽象类或者抽象方法!这里我们为了方便在本类中使用就没有使用抽象类/抽象方法 public class TemplateThread { //如果这个方法不想被子类或者别人随意改动[这样子类就不能覆写该方法了],这里方法就要设置为final方法 public final void println(String message){ System.out.println("###################

java多线程系类：JUC线程池：03之线程池原理（二）（转）

概要 在前面一章"Java多线程系列--"JUC线程池"02之 线程池原理(一)"中介绍了线程池的数据结构,本章会通过分析线程池的源码,对线程池进行说明.内容包括:线程池示例参考代码(基于JDK1.7.0_40)线程池源码分析(一) 创建"线程池"(二) 添加任务到"线程池"(三) 关闭"线程池" 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3509954.h

在java中怎样实现多线程？线程的4种状态

一.在java中怎样实现多线程? extends Thread implement Runnable 方法一:继承 Thread 类,覆盖方法 run(),我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可. 下面是一个例子: public class MyThread extends Thread { int count= 1, number; public MyThread(int num) { number = num; System.out.printl

多线程-----Thread类与Runnable接口的区别

第一个继承Thread类来实现多线程,其实是相当于拿出三件事即三个卖早餐10份的任务分别分给三个窗口,他们各做各的事各卖各的早餐各完成各的任务,因为MyThread继承Thread类,所以在newMyThread的时候在创建三个对象的同时创建了三个线程:实现Runnable的, 相当于是拿出一个卖早餐10份的任务给三个人去共同完成,newMyThread相当于创建一个任务,然后实例化三个Thread,创建三个线程即安排三个窗口去执行. 一个类只能继承一个父类,存在局限:一个类可以实现多个接口.在

Java 多线程——Thread类和Runable接口

在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口:Thread类是在java.lang包中定义的.一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了,但是一个类只能继承一个父类,这是此方法的局限, 下面看例子: [java] view plaincopy package org.thread.demo; class MyThread extends Thread{ private String name; public

多线程——Thread与Runnable的区别

首先,从使用形式上,使用Runnable实现多线程更好,因为避免了单继承问题,但除了这一点之外,Thread和Runnable之间也存在一些联系.观察Thread类的定义形式: public class Threadextends Objectimplements Runnable 原来Thread类是Runnable接口的子类,那么Thread类也应该覆写了run()方法. @Override public void run() { if (target != null) { target.r

JAVA多线程Thread与Runnable

一.Runnable Runnable为一个之包含一个run方法的接口 1 public class MyRunnable implements Runnable{ 2 @Override //表示:预示重写方法 3 public void run() { //实现接口run方法 4 System.out.println("实现Runnable的线程0.0\t"+Thread.currentThread().getName()); 5 6 } 7 8 public static voi