多线程总结

并发并行

并行：同一时刻同时处理多个任务。简单理解：一边......一边......

并发：同一时间段内，多个任务交替执行。简单理解：一会......一会......

进程和线程

进程是指正在运行的程序。

特点

• 进程是系统运行的基本单位
• 每个进程都有自己的独立空间，一组资源
• 每一个进程内部数据和状态都是完全独立的
• 每一个应用程序运行时都会产生一个进程

线程

线程是进程中执行运算的最小单位，一个进程执行过程中可以产生多个线程，线程必须在某个进程内执行。

一个进程中至少有一个线程，也可以有多个线程，这样的程序就称为多线程程序。

进程和线程的区别

进程：有独立的内存空间，进程中的数据存放空间（堆和栈）是独立的，至少有一个进程。

线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小得多。

资源分配给进程，同一进程的所有线程共享该进程的所有资源（如内存）。

处理器分配给线程，即真正在处理器上运行的是线程。

Java程序中至少包含两个线程：一个main()线程，另外一个是垃圾回收机制线程。

多线程和多进程的区别

本质区别在于，每个进程拥有一套自己的变量，而线程则是共享数据。

线程调度

分时调度：所有线程轮流拥有CPU的使用权，平均分配每个线程占用CPU的时间。

抢占式调度：优先让优先级高的线程使用CPU，如果优先级相同，会随机选择一个线程。

创建线程

每个程序至少自动拥有一个线程，称为主线程，当程序加载到内存中时启动主线程，main()就是主线程的入口。

创建线程的三种方法

继承Thread类，重写run()，通过start()启动线程。

public class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run() {
        //run方法里面写线程具体的任务
        for (int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

public class MyThreadTest {
    public static void main(String[] args) {
        //创建MyThread对象
        MyThread myThread = new MyThread("我的线程");
        //开启一个新的线程 实际上是去执行重写的run方法
        myThread.start();
        for (int i = 0; i < 100; i++){
            System.out.println("主线程运行了" + i + "次");
        }
    }
}

实现Runnable接口的方式创建

实现Runnale接口，重写run()方法

public class RunnableDemo {
    public static void main(String[] args) {
        Thread.currentThread().setName("主线程");
        Thread t = new Thread(new MyRunnaable());
        t.setName("子线程");
        t.start();
        //子线程运行后，主线程继续运行
        for (int i = 0; i < 10; i ++){
            System.out.println(Thread.currentThread().getName() + "运行了" + i + "次");
        }
    }
}
class MyRunnaable implements Runnable{
    @Override
    public void run() {
        //写子线程要执行的任务
        //输出1-100
        for (int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + "运行了" + i + "次");
        }
    }
}

Runnnable对象仅仅作为Thread对象的target，Runnale实现类里包含的run()仅仅作为线程的执行体，实际的线程对象依然是Thread实例，只是该实例负责执行该其target的run()。

Thread和Runnable的区别

实现Runnable接口比继承Thread的优势

1. 适合多个相同的程序代码的线程去共享一个资源
2. 避免单继承的局限性
3. 增加程序的健壮性，实现解耦，代码可以被多个线程共享
4. 实现Runnale接口很容易实现资源共享
5. 线程池也只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类

实现Callable接口的方式创建

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
 
public class CallableDemo implements Callable {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 10; i++){
            sum += i;
        }
        return sum;
    }
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable callable = new CallableDemo();
        FutureTask futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

Callable和Runnale比较相似，Runnable不返回结果，也不能抛出检查异常，Callable没有返回结果。

Callable和Runnable的区别

• Callable的call()有返回值，Runnale的run()没有返回值。
• call()可以抛出检查异常，run()不能。
• Callable接口的结果可以通过Future对象来获取。

FutureTask类

FutureTask是一个实现了Future和Runnable的类，它可以表示一个异步计算的结果，FutureTask可以包装一个Callable和Runnale对象，通过get()获取异步计算的结果。

Callable call = new Myacallable();
FutureTask task = new FutureTask(call);
Thread thread = new Thread(task);
thread.start();

构造方法

public class WatchThread extends Thread{
    //创建守护线程，检查C盘容量，少于1G发出预警
    File file = new File("C:");
    @Override
    public void run() {
        while (true){
            long space = file.getFreeSpace();
            System.out.println("C盘剩余空间：" + space / 1024 / 1024 / 1024 + "G");
            if(space < 1024 * 1024 * 1024){
                System.out.println("C盘空间不足");
            }
            try {
                //暂停5秒后继续监视
                sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void main(String[] args) {
        WatchThread thread = new WatchThread();
        //设置为守护线程，在start之前设置
        thread.setDaemon(true);
        thread.start();
    }
}

synchronized(锁对象){
// ...访问共享数据的代码...
}

CountDownLatch latch = new CountDownLatch(10);
latch.countDown(); // 每一个线程运行结束 数量减一
latch.await(); // 等待这个计数器中数字清空