Java Thread [Java多线程]

程序 & 进程 & 线程

程序[Program]是一个静态的概念，一般对应于操作系统中的一个可执行文件，比如：我们要启动Chrome浏览器，则加载对应可执行程序到内存中，开始执行该程序，于是产生了进程。

进程[Process]是执行中的程序，是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如：我们在用Chrome浏览网页，也可以同时使用编辑器写代码。进程具有如下特点：

1. 进程是程序的一次动态执行过程， 占用特定的地址空间。

2. 每个进程由3部分组成：cpu、data、code。每个进程都是独立的，保有自己的cpu时间，代码和数据，即便用同一份程序产生好几个进程，它们之间还是拥有自己的这3样东西，这样的缺点是：浪费内存，cpu的负担较重。

3. 多任务[Multitasking]操作系统将CPU时间动态地划分给每个进程，操作系统同时执行多个进程，每个进程独立运行。以进程的观点来看，它会以为自己独占CPU的使用权。

线程[Thread]可以理解为轻量级进程[lightweight process]。一个进程可以产生多个线程，就像同多个进程可以共享操作系统的某些资源一样，同一进程的多个线程也可以共享此进程的某些资源[比如：代码、数据]。线程具有如下特点：

1. 一个进程内部的一个执行单元，它是程序中的一个单一的顺序控制流程。

2. 一个进程可拥有多个并行的[concurrent]线程。

3. 一个进程中的多个线程共享相同的内存单元/内存地址空间，可以访问相同的变量和对象，而且它们从同一堆中分配对象并进行通信、数据交换和同步操作。

4. 由于线程间的通信是在同一地址空间上进行的，所以不需要额外的通信机制，这就使得通信更简便而且信息传递的速度也更快。

5. 线程的启动、中断、消亡，消耗的资源非常少。

进程和程序的区别

程序是一组指令的集合，它是静态的实体，没有执行的含义。而进程是一个动态的实体，有自己的生命周期。一般说来，一个进程肯定与一个程序相对应，并且只有一个，但是一个程序可以有多个进程，或者一个进程都没有。除此之外，进程还有并发性和交往性。简单地说，进程是程序的一部分，程序运行的时候会产生进程。

线程和进程的区别：

1. 线程和进程最根本的区别在于：进程是资源分配的单位，线程是调度和执行的单位。

2. 每个进程都有独立的代码和数据空间[进程上下文]，进程间的切换会有较大的开销。但是，线程可以看成是轻量级的进程，属于同一进程的线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器[PC]，线程切换的开销小。

3. 多进程: 在操作系统中能同时运行多个任务程序。多线程: 在同一应用程序中有多个顺序流同时执行。

4. 线程是进程的一部分，所以线程有的时候被称为轻量级进程。

5. 一个没有线程的进程是可以被看作单线程的，如果一个进程内拥有多个线程，进程的执行过程不是一条线[线程]的，而是多条线[线程]共同完成的。

6. 系统在运行的时候会为每个进程分配不同的内存区域，但是不会为线程分配内存[线程所使用的资源是它所属的进程的资源]，线程组只能共享资源。那就是说，除了CPU之外[线程在运行的时候要占用CPU资源]，计算机内部的软硬件资源的分配与线程无关，线程只能共享它所属进程的资源。

---

Java 多线程

Java创建多线程有三种方式，继承Thread类，实现Runnable接口，和实现Callable接口。最常见的是实现Runnable接口的方式，继承Thread方法次之，通过Callable接口很少使用。

继承Thread类

1. 在Java中负责实现线程功能的类是java.lang.Thread 类。

2. 可以通过创建Thread的实例来创建新的线程。

3. 每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。

4. 通过调用Thread类的start()方法来启动一个线程。

public class TestThread extends Thread {//自定义类继承Thread类
    //run()方法里是线程体
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + ":" + i);//getName()方法是返回线程名称
        }
    }
 
    public static void main(String[] args) {
        TestThread thread1 = new TestThread();//创建线程对象
        thread1.start();//启动线程
        TestThread thread2 = new TestThread();
        thread2.start();
    }
}

实现Runnable接口

在开发中，我们应用更多的是通过Runnable接口实现多线程。这种方式克服了实现线程类的缺点，即Java不允许多继承，所以继承Thread就无法继承其他类，但是在实现Runnable接口的同时还可以继承某个类。所以实现Runnable接口的方式要通用一些。这里使用了静态代理模式，Thread类就是一个代理，真实用户是我们自定义的TestThread2类，将TestThread2类作为参数传入，Thread会自动调用它的run()方法。

public class TestThread2 implements Runnable {//自定义类实现Runnable接口；
    //run()方法里是线程体；
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    public static void main(String[] args) {
        //创建线程对象，把实现了Runnable接口的对象作为参数传入；
        Thread thread1 = new Thread(new TestThread2());
        thread1.start();//启动线程；
        Thread thread2 = new Thread(new TestThread2());
        thread2.start();
    }
}

---

线程状态

个线程对象在它的生命周期内，需要经历5个状态。

新生状态[New]

用new关键字建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态，随时可以被CPU调用执行。

就绪状态[Runnable]

处于就绪状态的线程已经具备了运行条件，但是还没有被分配到CPU，处于线程就绪队列，等待系统为其分配CPU。就绪状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会进入执行状态。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。有4中原因会导致线程进入就绪状态：

1. 新建线程：调用start()方法，进入就绪状态;

2. 阻塞线程：阻塞解除，进入就绪状态;

3. 运行线程：调用yield()方法，直接进入就绪状态; yield()方法：可以让正在运行的线程直接进入就绪状态，让出CPU的使用权。

4. 运行线程：JVM将CPU资源从本线程切换到其他线程。

运行状态[Running]

在运行状态的线程执行自己run方法中的代码，直到调用其他方法而终止或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到就绪状态。也可能由于某些“导致阻塞的事件”而进入阻塞状态。

阻塞状态[Blocked]

阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪)。有4种原因会导致阻塞：

1. 执行sleep(int millsecond)方法，使当前线程休眠，进入阻塞状态。当指定的时间到了后，线程进入就绪状态。

2. 执行wait()方法，使当前线程进入阻塞状态。当使用nofity()方法唤醒这个线程后，它进入就绪状态。

3. 线程运行时，某个操作进入阻塞状态，比如执行IO流操作(read()/write()方法本身就是阻塞的方法)。只有当引起该操作阻塞的原因消失后，线程进入就绪状态。

4. join()线程联合: 合并两个线程，这两个线程会进行顺序执行，也就是当某个线程等待另一个线程执行结束后，才能继续执行时，使用join()方法。

死亡状态(Terminated)

死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。一个是正常运行的线程完成了它run()方法内的全部工作; 另一个是线程被强制终止，如通过执行stop()或destroy()方法来终止一个线程，当一个线程进入死亡状态以后，就不能再回到其它状态了。但是stop()/destroy()方法已经被JDK废弃，不推荐使用。通常的做法是提供一个boolean型的终止变量，当这个变量置为false，则终止线程的运行。

public class TestThreadCiycle implements Runnable {
    String name;
    boolean live = true;// 标记变量，表示线程是否可中止；
    public TestThreadCiycle(String name) {
        super();
        this.name = name;
    }
    public void run() {
        int i = 0;
        //当live的值是true时，继续线程体；false则结束循环，继而终止线程体；
        while (live) {
            System.out.println(name + (i++));
        }
    }
    public void terminate() {
        live = false;
    }
 
    public static void main(String[] args) {
        TestThreadCiycle ttc = new TestThreadCiycle("线程A:");
        Thread t1 = new Thread(ttc);// 新生状态
        t1.start();// 就绪状态
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程" + i);
        }
        ttc.terminate();
        System.out.println("ttc stop!");
    }
}

---

线程Join

线程A在运行期间，可以调用线程B的join()方法，让线程B和线程A联合。这样，线程A就必须等待线程B执行完毕后，才能继续执行。如下面示例中，爸爸线程要抽烟，于是联合了儿子线程去买烟，必须等待儿子线程买烟完毕，爸爸线程才能继续抽烟。

public class TestThreadState {
    public static void main(String[] args) {
        System.out.println("爸爸和儿子买烟故事");
        Thread father = new Thread(new FatherThread());
        father.start();
    }
}
 
class FatherThread implements Runnable {
    public void run() {
        System.out.println("爸爸想抽烟，发现烟抽完了");
        System.out.println("爸爸让儿子去买包红塔山");
        Thread son = new Thread(new SonThread());
        son.start();
        System.out.println("爸爸等儿子买烟回来");
        try {
            son.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("爸爸出门去找儿子跑哪去了");
            // 结束JVM。如果是0则表示正常结束；如果是非0则表示非正常结束
            System.exit(1);
        }
        System.out.println("爸爸高兴的接过烟开始抽，并把零钱给了儿子");
    }
}
 
class SonThread implements Runnable {
    public void run() {
        System.out.println("儿子出门去买烟");
        System.out.println("儿子买烟需要10分钟");
        try {
            for (int i = 1; i <= 10; i++) {
                System.out.println("第" + i + "分钟");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("儿子买烟回来了");
    }
}

---

线程优先级

处于就绪状态的线程，会进入“就绪队列”等待JVM来挑选。

线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级是5。

使用下列方法获得或设置线程对象的优先级。

int getPriority();

void setPriority(int newPriority);

注意：优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高的线程后调用优先级低的线程。

---

线程同步 & synchronized关键字

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候，我们就需要用到线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问造成的这种问题。

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized代码块。本质上说synchronized就是给对应的方法或代码块加上锁，要想访问需要先获得锁。

通过在方法声明中加入 synchronized关键字来声明，语法如下：

public synchronized void accessVal(int newVal);

synchronized方法控制对对象的类成员变量的访问：每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

synchronized方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率。

Java为我们提供了更好的解决办法，那就是synchronized代码块。代码块可以让我们精确地控制到具体的成员变量，缩小同步的范围，提高效率。

synchronized代码块：通过synchronized关键字来声明synchronized代码块，语法如下：

public class TestSync {
    public static void main(String[] args) {
        Account a1 = new Account(100, "高");
        Drawing draw1 = new Drawing(80, a1);
        Drawing draw2 = new Drawing(80, a1);
        draw1.start(); // 你取钱
        draw2.start(); // 你老婆取钱
    }
}
/*
 * 简单表示银行账户
 */
class Account {
    int money;
    String aname;
    public Account(int money, String aname) {
        super();
        this.money = money;
        this.aname = aname;
    }
}
/**
 * 模拟提款操作
 * 
 * @author Administrator
 *
 */
class Drawing extends Thread {
    int drawingNum; // 取多少钱
    Account account; // 要取钱的账户
    int expenseTotal; // 总共取的钱数
 
    public Drawing(int drawingNum, Account account) {
        super();
        this.drawingNum = drawingNum;
        this.account = account;
    }
 
    @Override
    public void run() {
        draw();
    }
 
    void draw() {
        synchronized (account) {
            if (account.money - drawingNum < 0) {
                System.out.println(this.getName() + "取款，余额不足！");
                return;
            }
            try {
                Thread.sleep(1000); // 判断完后阻塞。其他线程开始运行。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingNum;
            expenseTotal += drawingNum;
        }
        System.out.println(this.getName() + "--账户余额：" + account.money);
        System.out.println(this.getName() + "--总共取了：" + expenseTotal);
    }
}

synchronized(account) 意味着线程需要获得account对象的“锁”才有资格运行同步块中的代码。 Account对象的锁也称为互斥锁，在同一时刻只能被一个线程使用。A线程拥有锁，则可以调用同步块中的代码;B线程没有锁，则进入account对象的锁池队列等待，直到A线程使用完毕释放了account对象的锁，B线程得到锁才可以开始调用同步块中的代码。

---