1-5-5 Java工具类--多线程

进程与线程

进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。
线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

创建线程的三种方法

1） 继承Thread类，重写run()方法，run()方法代表线程要执行的任务。

2） 实现Runnable接口，重写run()方法，run()方法代表线程要执行的任务。

3） 实现callable接口，重写call()方法，call()作为线程的执行体，具有返回值，并且可以对异常进行声明和抛出；使用start()方法来启动线程

第三种方法介绍

1、 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

2、 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

3、 使用FutureTask对象作为Thread对象的target创建并启动新线程。

4、 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

实例代码:

import java.util.concurrent.Callable;

public class ThreeThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        String str = "多线程的第三种创建方式";
        return str;
    }
}

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

public class ThreeThreadTest {
    //测试方法
    public static void main(String[] args) {
        Callable<String> call = new ThreeThread();
        FutureTask<String> ft = new FutureTask<>(call);
        Thread t3 = new Thread(ft);

        //启动线程
        t3.start();

        try {
            System.out.println(ft.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

}

 线程状态和生命周期

 

sleep方法的使用

public static void sleep(long millis)

在指定的毫秒数内让正在执行的线程休眠(暂停执行)

参数为休眠时间,单位是毫秒

join方法使用

public final void join()

等待调用该方法的线程结束才能执行

public class JoinDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        try {
            mt.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程运行第" + i + "次");
        }
        System.out.println("主线程运行结束!");
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(getName() + "正在执行" + i + "次");
        }
    }
}

运行结果:

public final void join(long millis)

等待该线程终止的最长时间为millis毫秒

线程优先级

优先级用1-10表示,超过范围会抛出异常

主线程优先级默认为5

优先级常量

MAX_PRIORITY:最高优先级10

MIN_PRIORITY:最低优先级1

NORM_PRIORITY:默认优先级5

相关方法

public int getPriority() 获取线程优先级的方法

public void setPriority(int newPriority) 设置线程优先级的方法

线程间同步与通信

同步:synchronized

通信:wait,notify,notifyAll

public class Queue {

    private int n;
    boolean flag = false;

    public synchronized int get() {
        if (!flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费:"+n);
        flag = false;
        notifyAll();
        return n;
    }

    public synchronized void set(int n) {
        if(flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("生产:"+n);
        this.n=n;
        flag = true;//生产完毕,容器里面已经有数据
        notifyAll();
    }
}

public class Consumer implements Runnable {
    Queue queue;
    Consumer(Queue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            queue.get();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Producer implements Runnable {
    Queue queue;
    Producer(Queue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        int i=0;
        while (true) {
            queue.set(i++);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {

    public static void main(String[] args) {
        Queue queue=new Queue();
        new Thread(new Producer(queue)).start();
        new Thread(new Consumer(queue)).start();
    }
}