Java多线程

什么是线程

多线程是什么 

多线程是指从软件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）

如何在程序中创建出多条线程

继承Thread类

主线程

package com.itheima.d1;

public class ThreadTest1 {
    //main方法是由一条默认的主线程负责执行。
    public static void main(String[] args) {
        //3、创建WyTread线程类的对象代表一个线程
        Thread t = new MyThread();
        //4、启动线程
        t.start();//main线程 t线程

        for (int i = 1; i <= 5; i++) {
            System.out.println("主" + i);
        }
    }
}

 子线程

package com.itheima.d1;
//1、让子类继承Thread线程类
public class MyThread extends Thread{
    //2、必须重写Thread类的run方法

    @Override
    public void run() {
        //描述线程的执行任务
        for (int i = 1; i <= 5; i++) {
            System.out.println("子" + i);
        }
    }
}

 注意事项

 实现Runnable接口

主线程 

package com.itheima.d1;

public class Test2 {
    public static void main(String[] args) {
        //3、创建任务对象
        Runnable target = new MyRunnable();
        //4、把任务对象交给一个线程对象处理
        //public Thread（ Runnable target）
        new Thread(target).start();

        for (int i = 1; i <= 5; i++) {
            System.out.println("主" + i);
        }
    }
}

子线程

package com.itheima.d1;
//1、定义一个任务类，实现Runnable接口
public class MyRunnable implements Runnable{
    //2、重写Runnable的run方法
    @Override
    public void run() {
        //线程要执行的流程
        for (int i = 1; i <= 5; i++) {
            System.out.println("子" + i);
        }
    }
}

匿名内部类

package com.itheima.d1;

public class Test22 {
    public static void main(String[] args) {
        //1、直接创建Runnable接口的匿名内部类形式（任务对象）
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子1" + i);
                }
            }
        };
        new Thread(target).start();


        //简化形式1
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子2" + i);
                }
            }
        }).start();


        //简化形式2
        new Thread(() -> {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子3" + i);
            }
        }).start();

        for (int i = 1; i <= 5; i++) {
            System.out.println("主" + i);
        }
    }
}

 实现Callable接口

  

主线程

package com.itheima.d1;

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

public class Test3 {
    public static void main(String[] args) throws Exception {
        //3、创建一个Callable的对象
        Callable<String> call = new MyCallable(100);
        //4、把Callable的对象封装成一个FutureTest对象（任务对象）
        //未来任务对象的作用
        //1、是一个任务对象，实现了Runnable对象
        //2、可以在线程执行完毕后，用未来任务对象调用get方法获取线程执行完毕后的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5、把任务对象交给一个Thread对象
        new Thread(f1).start();

        Callable<String> call2 = new MyCallable(100);
        FutureTask<String> f2 = new FutureTask<>(call);
        new Thread(f1).start();

        //6、获取线程执行完毕后的结果
        //注意：如果先咨询到这，假如上面的线程还没有执行完毕
        //这里的代码会暂停，等待上面的代码执行完毕后才会获取结果
        String rs = f1.get();
        System.out.println(rs);

        String rs2 = f1.get();
        System.out.println(rs2);
    }
}

子线程

package com.itheima.d1;

import java.util.concurrent.Callable;

//1、让这个类实现Callable接口
public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n){
        this.n = n;
    }

    //2、重写call方法
    @Override
    public String call() throws Exception {
        //描述线程的任务，返回线程执行返回后的结果。
        //需求：1-n的和返回
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "1到n的和" + sum;
    }
}