Java并发编程之线程的三种实现方式

 一.进程和线程的区别及关系

 

1.线程是进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间。

2.资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源。

3.线程是处理器调度的基本单位,但进程不是。

4.二者均可并发执行，因此也会出现并发问题，需要做并发控制。

5.只有多核cpu才能实现真正意义上的多线程，单核cpu只能模拟多线程。

二.线程的状态

1.新建：用new语句创建的线程对象处于新建状态，此时它和其他java对象一样，仅被分配了内存。

2.等待：当线程在new之后，并且在调用start方法前，线程处于等待状态。

3.就绪：当一个线程对象创建后，其他线程调用它的start()方法，该线程就进入就绪状态。处于这个状态的线程位于Java虚拟机的可运行池中，等待cpu的使用权。

4.运行：处于这个状态的线程占用CPU，执行程序代码。在并发运行环境中，如果计算机只有一个CPU，那么任何时刻只会有一个线程处于这个状态。只有处于就绪状态的线程才有机会转到运行状态。

5.阻塞：阻塞是指线程因为某些原因放弃CPU，暂时停止运行。当线程处于阻塞状态时，Java虚拟机不会给线程分配CPU，直到线程重新进入就绪状态，它才会有机会获得运行状态。

三.Java 中用到的线程调度算法

计算机通常只有一个 CPU,在任意时刻只能执行一条机器指令,每个线程只有获得 CPU 的使用权才能执行指令. 所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得 CPU的使用权,分别执行各自的任务.在运行池中,会有多个处于就绪状态的线程在等待CPU,JAVA 虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配 CPU 的使用权java 虚拟机采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用 CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用 CPU。处于运行状态的线程会一直运行，直至它不得不放弃 CPU。

一个线程会因为以下原因而放弃 CPU。

• java 虚拟机让当前线程暂时放弃 CPU，转到就绪状态，使其它线程获得运行机会。

• 当前线程因为某些原因而进入阻塞状态

• 线程结束运行

需要注意的是，线程的调度不是跨平台的，它不仅仅取决于 java 虚拟机，还依赖于操作系统。在某些操作系统中，只要运行中的线程没有遇到阻塞，就不会放弃 CPU；

在某些操作系统中，即使线程没有遇到阻塞，也会运行一段时间后放弃 CPU，给其它线程运行的机会。 java 的线程调度是不分时的，同时启动多个线程后，不能保证各个线程轮流获得均等的 CPU 时间片。 如果希望明确地让一个线程给另外一个线程运行的机会，可以采取以下办法之一。

调整各个线程的优先级

• 让处于运行状态的线程调用 Thread.sleep()方法

• 让处于运行状态的线程调用 Thread.yield()方法

• 让处于运行状态的线程调用另一个线程的 join()方法

四.线程的三种实现方式

0.继承Thread类，实现Runnable接口，实现Callable接口（高级）。

1.线程类实现了Runnable接口或Callable接口，还可以继承其他类。但是编程稍复杂，访问当前线程，则必须使用Thread.currentThread()方法，而使用继承Thread类的方式时，访问当前线程，直接使用this即可获得当前线程。

2.Runnable和Callable的区别：

(1) Callable重写的是call()，Runnable重写的是run()。

(2) Callable的任务执行后可返回值，抛出异常，而Runnable的任务是不行。

(4) 运行Callable任务可以拿到一个Future对象，表示异步计算的结果。提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

上代码。

Thread：

package thread;

/**
 * 创建线程的方式一：继承Thread类，重写run方法
 * @author liucong
 */
public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println("吃着火锅1");
        }
    }
}

Runnable:

package runnable;

/**
 * 多线程的创建方式二 实现Runnable接口，重写run方法
 * @author liucong
 */
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println("吃着火锅2");
        }
    }
}

Callable:

package callable;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for(int i = 0; i < 10; i++) {
            System.out.println("吃着火锅3");
        }
        return true;
    }
}

Test:

package test;

import callable.MyCallable;
import runnable.MyRunnable;
import thread.MyThread;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 线程测试类
 * @author liucong
 */
public class ThreadTest {

    public static void main(String[] arge) {
        //1.测试Thread类
        MyThread myThread = new MyThread();
        myThread.start();
        for(int i = 0; i < 10; i++) {
            System.out.println("唱着歌1");
        }

        //2.测试Runnable接口
        MyRunnable myRunnable = new MyRunnable();
        //创建代理线程对象
        Thread thread = new Thread(myRunnable);
        thread.start();
        for(int i = 0; i < 10; i++) {
            System.out.println("唱着歌2");
        }

        //3.测试Callable接口
        MyCallable myCallable = new MyCallable();
        //1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收结果。
        FutureTask<Boolean> futureTask = new FutureTask<>(myCallable);
        Thread thread1 = new Thread(futureTask);
        thread1.start();
        try {
            Boolean result = futureTask.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        for(int i = 0; i < 10; i++) {
            System.out.println("唱着歌3");
        }
    }
}