java知识之----多线程（一）

一：并发、并行

并发：指二个或多个事件在同一时间段内发生。

并行：指二个或多个事件在同一时刻发生（同时发生）。

二：线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创 建、运行到消亡的过程。 

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

三：创建线程的方式

 方式一：创建Thread类的子类重写其run()方法

    java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类

构造方法：

public Thread() :分配一个新的线程对象。

public Thread(String name) :分配一个指定名字的新的线程对象。

public Thread(Runnable target) :分配一个带有指定目标新的线程对象。

public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
 

常用方法：

public String getName() :获取当前线程名称。

public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

public void run() :此线程要执行的任务在此处定义代码。

public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

public static Thread currentThread() :返回对当前正在执行的线程对象的引用

    实现步骤:

    1.创建一个Thread类的子类
        2.在Thread类的子类中重写Thread类中的run方法,设置线程任务
        3.创建Thread类的子类对象
        4.调用Thread类中的方法start方法,开启新的线程,执行run方法，void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

//1.创建一个Thread类的子类
public class MyThread extends Thread{
    //2.在Thread类的子类中重写Thread类中的run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("run:"+i);
        }
    }
}

public class TestThreadDemo {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread myt = new MyThread();
        //4.调用Thread类中的方法start方法,开启新的线程,执行run方法
        myt.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println("main:"+i);// 主线程中的任务
        }
    }
}

代码的运行结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）。

方式二：实现Runnable接

java.lang.Thread类的构造方法：

   Thread(Runnable target) 分配新的 Thread 对象。

   Thread(Runnable target, String name) 分配新的 Thread 对象。

实现步骤:

       1.创建一个Runnable接口的实现类
        2.在实现类中重写Runnable接口的run方法,设置线程任务
        3.创建一个Runnable接口的实现类对象
        4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        5.调用Thread类中的start方法,开启新的线程执行run方法

//1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    //2.在实现类中重写Runnable接口的run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

public class Demo01Runnable {
    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        // RunnableImpl run = new RunnableImpl();
        //4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        //Thread t = new Thread(run);//打印线程名称

        Thread t = new Thread(new RunnableImpl1());//打印线程名称
        //5.调用Thread类中的start方法,开启新的线程执行run方法
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

使用Runnable接口实现多线程比继承Thread类实现多线程的好处：

 1.避免了单继承的局限性
            一个类只能继承一个类,类继承了Thread类就不能继承其他的类
            实现了Runnable接口,还可以继承其他的类,实现其他的接口
2.增强了程序的扩展性,降低了程序的耦合性(解耦)
            实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
            实现类中,重写了run方法:用来设置线程任务
            创建Thread类对象,调用start方法:用来开启新线程