• 程序
• 进程
• 线程
• 线程和进程的区别
• 进程和程序的区别
• Java中实现多线程
  • 通过继承Thread类实现多线程
  • 通过Runnable接口实现多线程
• 线程状态
  • (New) 新生状态
• （Runnable）就绪状态
• （Running）运行状态
• (Blocked) 阻塞状态
• （Terminated）死亡状态
  • 终止线程的典型方法(重要)
  • 暂停线程执行常用方法
  • 线程的联合 join()
• 线程基本信息
  • 线程优先级
• 线程同步
• 死锁及解决方案
• 线程并发协作
• 任务定时调度

程序

“程序(Program)”是一个静态的概念，一般对应于操作系统中的一个可执行文件。

进程

执行中的程序叫做进程(Process)，是一个动态的概念。现代的操作系统都可以同时启动多个进程。

特点：

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

2. 每个进程由3部分组成：cpu、data、code。

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

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

4. 进程的查看

   Windows系统: Ctrl+Alt+Del，启动任务管理器即可查看所有进程。

   Unix系统: ps or top。

线程

一个进程可以产生多个线程。同多个进程可以共享操作系统的某些资源一样，同一进程的多个线程也可以共享此进程的某些资源(比如：代码、数据)，所以线程又被称为轻量级进程(lightweight process)。

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

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

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

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

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

线程和进程的区别

• 最根本区别：进程是资源分配的单位，线程是调度和执行的单位

• 进程间的切换开销较大（每个进程有独立的code和数据空间【进程上下文】）

• 线程切换开销小（同一进程的线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器PC）

• 多进程：在操作系统中能同时运行多个程序（任务）

• 多线程：在同一应用程序中有多个顺序流同时执行

• 线程是进程的一部分，所以线程被称作【轻量级进程】

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

• 除了CPU之外(线程在运行的时候要占用CPU资源)，计算机内部的软硬件资源的分配与线程无关，线程只能共享它所属进程的资源。

进程和程序的区别

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

Java中实现多线程

通过继承Thread类实现多线程

public class MyThread extends Thread {
    // 线程体
    public void run() {
        try {
            // getName() 返回线程名称
            System.out.println(this.getName() + ":" + i);
            sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
    	MyThread t1 = new MyThread();
        t1.start();
        MyThread t2 = new MyThread();
        t2.start();
    }
}

缺点：若自定义类MyThread先前就继承了一个类，则无法再继承Thread类

通过Runnable接口实现多线程

开发中常用Runnable 接口实现多线程，在实现Runnable接口的同时还可以继承某个类。

public class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            sout(Thread.currentThread().getName() + ":" + i);
        }
    }
    
    public static void main(String[] args) {
        //创建线程对象，把实现了Runnable接口的对象作为参数传入
        Thread t1 = new Thread(new MyThread());
        t1.start();
        Thread t2 = new Thread(new MyThread());
        t2.start();
    }
}

线程状态

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

(New) 新生状态

用 new 关键字建立一个线程对象后，该线程就处于新生状态。

处于新生状态的线程有自己的内存空间，通过调用 start() 进入【就绪状态】。

（Runnable）就绪状态

处于就绪状态的线程已具备了运行条件，但还没被分配到cpu，处于【线程就绪队列】，等待系统分配其CPU。

就绪状态不是执行状态，当系统选定一个等待执行的Thread对象后，它就会进入执行状态。

一旦获得CPU，线程就进入【运行状态】并自动调用自己的 run方法。有4中情况会导致线程进入就绪状态：

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

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

3. 运行线程：调用yield()方法，直接进入就绪状态;

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废弃

  当一个线程进入死亡状态以后，就不能再回到其它状态了。

终止线程的典型方法(重要)

public class MyThreadCircle implements Runnable {
    String name;
    boolean live = true; // 标记变量
    
    public static void main(String[] args) {
        MyThreadCircle ttc = new MyThreadCircle("线程A：");
        Thread t = new Thread(ttc);  // 新生状态
        t.start();  // 就绪状态
        for (int i = 0; i < 100; i++) {
            print("主线程：" + i);
        }
        ttc.terminate();
        print("ttc stop");
    }
    @Override
    public void run() {
        int i = 0;
        while (live) {
            print(name + (i++));
        }
    }
    
    public void terminate() {
        live = false;
    }
}

暂停线程执行常用方法

• sleep()，（如上Java中实现多线程）可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态
• yield()，可以让正在运行的线程直接进入就绪状态，让出CPU的使用权

线程的联合 join()

线程A在运行期间，可以调用线程B的 join() 方法，让线程B和线程A联合。这样，线程A就必须等待线程B执行完毕后，才能继续执行。

public class TestThreadJoin {
    public static void main(String[] args) {
        System.out.println("线程A就必须等待线程B执行完毕后，才能继续执行");
        Thread A = new Thread(new ThreadA());
        A.start();
    }
}

class ThreadA implements Runnable {
    @Override
    public void run() {
        Thread B = new Thread(new ThreadB());
        B.start();
        System.out.println("线程A等待线程B执行完毕");
        try {
            B.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            // 结束JVM。如果是0则表示正常结束；如果是非0则表示非正常结束
            System.exit(1);
        }
        System.out.println("线程A开始执行\n....");
    }
}

class ThreadB implements Runnable {
    @Override
    public void run() {
        System.out.println("线程B开始执行");
        try {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程B执行的第" + (i+1) +"分钟");
            Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程B执行完毕");
    }
}

结果：

线程A就必须等待线程B执行完毕后，才能继续执行
线程A等待线程B执行完毕
线程B开始执行
线程B执行的第1分钟
线程B执行的第2分钟
线程B执行的第3分钟
线程B执行的第4分钟
线程B执行的第5分钟
线程B执行完毕
线程A开始执行
....

线程基本信息

线程优先级

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

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

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

  • int getPriority();
  • void setPriority(int newPriority);

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

线程同步

线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。

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

• synchronized 在方法声明中加入该关键字

  public synchronized void accessVal(int newVal);
  

  synchronized 方法控制对【对象的类成员变量】的访问：

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

• synchronized 块

  synchronized 修饰方法的缺点：另外线程必须等待整个方法执行完毕，将会大大影响效率

  synchronized 块可以让我们精确地控制到具体的【成员变量】，缩小同步的范围，提高效率

  synchronized(syncObj) { // ... }
  

线程同步实例：

public class TestThreadSync {
    
}

/*简单表示银行账户*/
class Account {
    int money;
    String name;
    public Account(int money, String name) {
        super();
        this.money = money;
        this.name = name;
    }
}

/**/
class Drawing extends Thread {
    int drawingMoney;  // 取多少钱
    Account account;  // 取钱的账户
    int totalDrawing;  // 总共取的钱数
    public Drawing(int drawingMoney, Account account){
        super();
        this.drawingMoney = drawingMoney;
        this.account = account;
    }
    
    void draw() {
        synchronized(account) {
            if (account.money - drawingMoney < 0) {
                print(this.getName() + " 取款，余额不足");
                return ;
            }
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingMoney;
            totalDrawing += drawingMoney;
        }
        System.out.println(this.getName() + "-->总共取了：" + totalDrawing);
        System.out.println(this.getName() + "-->账户余额：" + account.money);
    }
    
    @Override
    public void run() {
        draw();
    }
}

Thread-1，取款，余额不足
Thread-0-->总共取了：80
Thread-0-->账户余额：20

如果没有线程同步机制，两个线程同时操作同一个账户对象：

Thread-0-->总共取了：80
Thread-0-->账户余额：20
Thread-1-->总共取了：80
Thread-1-->账户余额：-60

死锁及解决方案

TODO

线程并发协作

TODO

任务定时调度

TODO

速学堂Notes