Java中的多线程(一)

简单认识线程

在了解线程之前我们先了解一下关于线程的其他概念吧

程序（program）： 指为完成特定任务、用某种语言编写的 一组指令的集合。

进程： 进程是指 运行中的程序，比如我们平时使用微信，就相当于启动了一个进程，操作系统就会为该进程分配内存空间。进程是程序的一次执行过程，或是正在运行的一个程序。是一种动态过程，有自身的产生、存在和消亡的过程。
线程： 线程是由进程创建的，是进程的一个实体。一个进程可以拥有多个线程。比如：我们日常中使用到的应用商店，我们打开商店就是一个线程，在商店内部下载不同需要的软件的下载的软件任务就是线程
单线程：同一个时刻，只允许执行一个线程。
多线程： 同一时刻，可以执行多个线程。
并发： 同一时刻，多个任务交替进行，造成一种“貌似同时”的错觉，简单的说，单核CPU实现的多任务就是并发。
并行： 同一时刻，多个任务同时执行，多核CPU可以实现并行。并发并行可以同时存在。

线程与进程直接的关系

首先说明进程与线程之间的关系 ： 进程中包含一条或多条线程；
第二从系统管理与分配资源和CPU调度的角度来分析：进程是系统分配资源的最小单位，线程是CPU调度的最小单位；
第三从资源使用角度来分析：进程之间不能共享资源，进程中的线程之间共享进程的所有资源；
单独介绍一下线程的特点：线程的创建、销毁、调度效率比进程更高，并且有自己独立的执行任务。

线程的使用

那么下面我们就来编写一个线程代码

继承Thread 类

第一种方法继承Thread 类，并重写run方法

package Thread;
class MyThread extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("hello word");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread thread=new MyThread();
        thread.start();
    }
}

这里我们就会发现我们通过对象thread调用里面的run方法不是可以达到一样的效果吗

package Thread;
class MyThread extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("hello word");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.run();
    }
}

这里如果通过调用run方法就要等到run方法执行完毕才可以执行其他的代码，这就造成了阻塞，而通过start就可以实现多线程的目的

package Thread;
class MyThread extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("hello word");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread thread=new MyThread();
        thread.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

上述程序 执行过程中，会打开一个进程，进入main主线程。当执行start时，会执行Thread-0子线程。

实现Runnable接口

package Thread;
class MyRunnable implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("hell t");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable runnable=new MyRunnable();
        Thread t=new Thread(runnable);
        t.start();
        while (true){
            System.out.println("hello main");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
}

这里MyRunnable类实现了Runnable接口和继承Thread相似，但有略有不同

继承Thread和实现Runnable接口的区别

1.从java的设计上看，通过继承Thread类与实现Runnable接口的方式来创建线程本质上没有区别，从jdk文档中，我们可以知道，Thread类本身就实现了Runnable接口；
2.实现Runnable接口的方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制