java多线程

1、线程概述

    几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。

    当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。

2、线程和进程

    几乎所有的操作系统都有进程的概念，所有运行中的任务通常对应一条进程。当一个程序进入内存运行，就是一个进程了。

    进程是处于运行中的程序，具有一定的独立能力，进程是系统进行资源分配和调度的一个独立单位。

  进程特征：

    A、独立性：进程是系统中独立存在的实体，可以拥有自己独立的资源，每个进程都拥有自己的私有地址地址。

            在没有经过进程本身允许的情况下，一个用户进程不可以访问其他进程地址空间。

    B、动态性：进程和程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。

            在程序中加入了时间概念，进程具有自己的生命周期和各种不同的状态，这些概念是程序不具备的。

    C、并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

    多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。线程也被称为轻量级进程(Lightweight Process)，线程是进程的执行单元。

就像进程在操作系统中的地位一样，线程在程序中是独立、并发执行流。当进程被初始化后，主线程就被创建。对于绝大多数应用程序来说，通常仅要一个主线程，

但我们也可以在该进程内创建多条顺序执行流，这些顺序执行流就是线程，每条线程也互相独立的。

    线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆、栈、程序计数器、局部变量，但不能拥有系统资源，

它与父进程的其他线程共享该进程所有的全部资源。因为多个线程共享父进程的全部资源。

    线程可以完成一定的任务，可与其他线程共享父进程中的变量和部分环境，相互之间协作共同完成进程所要完成的任务。

    线程是独立运行的，它并不知道进程中是否还有其他进程存在。线程的执行是抢占方式的，也就是说，当前运行的线程在任何时候都可以被挂起，以便其他线程运行。

一个线程可以创建和撤销另一个线程，同一个进程中的多个线程可以并发执行。

综述：一个程序运行后至少有一个进程，一个进程可以包含多个线程。至少包含一个线程。

3、并发和并行

    并发性(concurrency)和并行性(parallel)是两个概念；

    并行指在同一时刻，有多条指令（线程）在多个处理器上同时执行；

    并发指在同一时刻只能有一个指令（线程）执行，但多个进程指令被快速轮换执行，使得宏观上具有多个进程同时执行的效果。

4、多线程的优势

    线程划分尺度小于进程，使得多线程划分的并发性高。进程在执行时有自己独立的单元，多个线程共享内存，从而提高了运行效率。

    线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性：多个线程将共享同一个进程的虚拟空间。

    线程共性的环境包括：进程代码段、进程共有数据等。线程很容易就利用共性的数据进行通信。

    当操作系统创建一个进程时，必须给该进程分别独立的内存空间，并分配大量相关的资源；但创建一个线程则简单得多，因此多线程来实现并发要比多进程实现并发的性能高得多。

多线程优点：

    A、进程之间不能共享内存，但线程之间共享内存非常容易。

    B、系统创建进程需要为该进程重新分配系统资源，但创建线程则代价要小得多，因此使用线程来实现多任务并发比多进程的效率高。

    C、Java语言内置多线程功能支持，而不是单纯的作为底层操作系统的调度方式，从而简化Java的多线程编程。

5.线程的实现
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

继续Thread类：必须覆写Thread类中的run()方法，run()方法中定义了线程要执行的代码

class 类名称 extends Thread {
    属性：
    方法：
    //覆写Thread类中的run方法
    public void run() {
        线程主题;
    }
}

 继承Thread类创建和执行多线程步骤：

（1）定义一个类扩展Thread

（2）覆盖run() 方法，这个方法中实现线程中要执行的操作

（3）创建一个这个线程类的对象

（4）调用start() 方法启动线程对象

例：

class CountingThread extends Thread {
    private String name;
    public CountingThread(String name) {
        this.name = name;
    }
    public void run() {
        System.out.println("Thread start:" + this.name);
        for (int i = 0; i < 9; i++) {
            System.out.println(name + " run:" + (i + 1) + "	");
        }
        System.out.println("Thread finish:" + this.name);
    }
}
class ThreadDemo {
    public static void main(String[] args) {
        CountingThread thread1 = new CountingThread("Thread A");
        CountingThread thread2 = new CountingThread("Thread B");
        thread1.start();
        thread2.start();
    }
}

实现Runnable接口：

  （1）定义一个类实现Runnable接口:implements Runnable

  （2）覆写其中的run() 方法

  （3）创建Runnable 接口实现类的对象

  （4）创建Thread类的对象（以Runnable子类对象为构造方法参数）

  （5）用start() 方法启动线程

例：

class CountingThread implements Runnable {
    private String name;
    public CountingThread(String name) {
        this.name = name;
    }
    public void run() {
        System.out.println("Thread start:" + this.name);
        for(int i = 0; i < 10; i++) {
            System.out.println(name + " run: i = " + i);
        }
        System.out.println("Thread end:" + this.name);
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
        CountingThread ct1 = new CountingThread("Thread A");
        CountingThread ct2 = new CountingThread("Thread B");
        Thread thread1 = new Thread(ct1);
        Thread thread2 = new Thread(ct2);
        thread1.start();
        thread2.start();
    }
}

6.线程的基本控制

1.线程睡眠：public static void sleep(long millis) throws InterruptedException

   当前线程将睡眠millis毫秒，可以使优先级低的线程得到执行的机会

2.线程状态测试：

   线程由start()方法启动后，直到其被终止之间的任何时刻，都处于活动状态

   可以通过Thread中的 isAlive() 方法来获取线程是否处于活动状态

   定义：public final boolean isAlive()

3.线程加入：public final void join() throws InterruptedException

   有一个A线程正在运行，希望插入一个B线程，并要求B线程先执行完毕，然后再继续A的执行

4.线程让步：public static void yield()

   不能指定暂停多长时间，会将CPU的占有权交给具有相同优先级的线程，否则继续运行原线程

   注意：只能让同优先级的线程有执行机会