多线程学习笔记1

概念:

并发和并行

• 并行:在同一时刻,有多个指令在多个cpu上同时执行

方便记忆:五个人(多个cpu)开黑玩游戏,人手一部手机,五个人是在同时执行.为并行

• 并发:在同一时刻,有多个指令在单个cpu上交替执行

方便记忆:一个人用五部手机玩开黑游戏,需要快速在五部手机之间切换,某一瞬间,这个人只在一部手机上操作,所以是交替执行.

进程和线程

进程:是正在运行的软件

• 独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位.
• 动态性:进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的.
• 并发性:任何进程都可以同其他进程一起并发执行

线程:是进程中单个顺序控制流,是一条执行路径.

方便记忆:360软件中可以同时执行清理垃圾\电脑查杀等,每一条执行路径都为一个线程.

• 单线程:一个进程如果只有一条执行路径,则成为单线程程序.
• 多线程:一个进程如果有多条执行路径,则成为多线程程序.

---

多线程的实现方案

• 继承Thread类的方式进行实现
• 实现Runnable接口的方式进行实现
• 利用Callable和Future接口方式实现

方案1:继承Thread类

• 定义一个类MyThread继承Thread类
• 在MyThread类中重写run()方法
• 创建MyThread类的对象
• 启动线程

//自定义线程类
public class MyThread extends Thread {
    @Override
    public void run() {
        //多线程需要执行的逻辑代码
        for (int i = 0; i < 100; i++) {
            System.out.println("线程"+Thread.currentThread().getName()+"打印"+i);
        }
    }
}


//测试类
public class Demo {
    public static void main(String[] args) {
        MyThread my1= new MyThread();
        MyThread my2= new MyThread();
        my1.start();//start方法与本地操作系统进行交互,开启一条线程
        my2.start();
    }
}

run():封装线程执行代码,直接调用,相当于普通方法的调用,并没有开启线程

start():启动线程;然后由JVM调用此线程的run()方法

方案2:实现Runnable接口

• 定义一个类MyRunnable接口
• 在MyRunnable类中重写run()方法
• 创建MyRunnable类的对象
• 创建Thread类的对象,把MyRunnable对象作为构造方法的参数
• 启动线程.

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程"+Thread.currentThread().getName()+"打印"+i);
        }
    }
}


//测试类
public class MyTest {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());
        thread1.start();
        thread2.start();
    }
}

方案3:Callable和Future

• 定义一个类MyCallable实现callable接口
• 在MyCallable类中重写call()方法
• 创建MyCallable类的对象
• 创建Future的实现类FutureTask对象,把MyCallable对象作为构造方法的参数
• 创建Thread类的对象,把FutureTask对象作为构造方法的参数
• 启动线程

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"打游戏"+i);
        }
        //返回值就是表示线程运行完毕之后的接口，
        // 返回值类型与Callable<T>的T类型一致
        return "胜利";
    }
}

//测试类
public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        FutureTask<String> ft = new FutureTask<>(mc);

        Thread th= new Thread(ft);
        th.start();

        //放在线程开启后的位置，如果线程没有结束一直等待
        String s = ft.get();
        System.out.println(s);
    }
}

小结:

 

	优点	缺点
实现Runnable\Callable接口	拓展性强,实现该接口的同时还可以继承其他的类	编程相对复杂,不饿能直接使用Thread类中的方法
继承Thread类	编程比较简单,可以直接使用Thread类中的方法	可扩展性较差,不能再继承其他的类