java进阶开发-----多线程

多线程
线程是一个程序的单一顺序执行流程。多个单一流程一起运行就是多线程
多线程是并发执行的。

创建线程有两种方式
第一种:继承Thread并重写run方法
第二种:实现Runnable接口单独定义线程任务。

第一种创建方式
优点:结构简单，利于匿名内部类创建
缺点：由于java是单继承的，这导致如果继承了Thread就无法再继承其他类了
在定义线程时定义了线程任务，这导致任务与线程存在了必然的耦合关系不利于线程的重用

public class ThreadDemo1 {
    public static void main(String[] args) {
        //1实例化线程
        Thread t1 = new MyThread1();
        Thread t2 = new MyThread2();
        //2启动线程
        t1.start();
        t2.start();
    }
}
class MyThread1 extends Thread{
    public void run(){
        for (int i=0;i<100;i++){
            System.out.println("我喜欢你");
        }
    }
}
class MyThread2 extends Thread{
    public void run(){
        for (int i=0;i<100;i++){
            System.out.println("不好意思，我有对象了");
        }
    }
}

第二种创建线程的方式
实现Runnable接口单独定义线程任务。//灵活

public class ThreadDemo2 {
    public static void main(String[] args) {
        //1创建线程任务
        Runnable r1 = new MyRunnable1();
        Runnable r2 = new MyRunnable2();

        //2创建两条线程分别执行任务
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);

        //3启动线程
        t1.start();
        t2.start();
    }
}

class MyRunnable1 implements Runnable{
    public void run() {
        for (int i=0;i<1000;i++){
            System.out.println("我喜好你");
        }
    }
}
class MyRunnable2 implements Runnable{
    public void run() {
        for (int i=0;i<1000;i++){
            System.out.println("不好意思，我有对象了！");
        }
    }
}

使用匿名内部类的创建方式完成线程的两种创建形式。
第一种:继承Thread重写run方法的形式
第二种:实现Runnable接口单独定义线程任务的形式
注意！启动线程调用的是线程的start方法，不能直接调用run方法！
start方法调用后线程会被纳入到线程调度器中被统一管理。当它第一次获取了调度器
分配给它的CPU时间片后就会开始执行run方法。

public class ThreadDemo3 {
    public static void main(String[] args) {
        //第一种:继承Thread重写run方法的形式
        Thread t1 = new Thread(){
            public void run(){
                for (int i=0;i<1000;i++){
                    System.out.println("我喜欢你");
                }
            }
        };
        //第二种:实现Runnable接口单独定义线程任务的形式
        Runnable r2 = new Runnable() {
            public void run() {
                for (int i=0;i<1000;i++){
                    System.out.println("不好意思，我有对象了！");
                }
            }
        };
        Thread t2 = new Thread(r2);
        /*
            启动线程调用的是线程的start方法，不能直接调用run方法！
            start方法调用后线程会被纳入到线程调度器中被统一管理。
            当它第一次获取了调读器
            分配给它的CPU时间片后就会开始执行run方法。
         */
        t1.start();
        t2.start();
    }
}

sleep阻塞

线程提供了一个静态方法sleep，可以使运行该方法的线程阻塞指定毫秒。超时后线程会自动回到
RUNNABLE状态继续并发运行

import java.util.Scanner;

public class SleepDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        /*
            倒计时程序
            输入一个数字，然后从该数字开始每秒递减，到0时输出时间到
         */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字:");
        for(int num = scanner.nextInt();num>0;num--) {
            System.out.println(num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("时间到！程序结束了...");
    }
}

当一个线程调用sleep方法处于睡眠阻塞的过程中其interrupt()方法被掉用，那么这时会中断
该睡眠阻塞，并且sleep方法会抛出中断异常

public class SleepDemo2 {
    public static void main(String[] args) {
        Thread lin = new Thread(){
            public void run(){
                System.out.println("林:刚美完容，睡一会吧~");
                try {
                    Thread.sleep(50000000);
                } catch (InterruptedException e) {
                    System.out.println("林:干嘛呢！干嘛呢！干嘛呢！都破了相了!");
                }
                System.out.println("林:醒了");
            }
        };

        Thread huang = new Thread(){
            public void run(){
                System.out.println("黄:大锤80！小锤40！开始砸墙!");
                for(int i=0;i<5;i++){
                    System.out.println("黄:80！");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                    }
                }
                System.out.println("咣当");
                System.out.println("黄:大哥！搞定！");
                lin.interrupt();//中断lin线程(如果线程处于睡眠阻塞，则是中断该阻塞状态)
            }
        };

        lin.start();
        huang.start();
    }
}

java中所有的代码都是靠线程运行的，main方法也不例外。
java程序跑起来后，JVM会创建一条线程来执行main方法，这个线程的名字也叫"main",我们
通常称呼它为"主线程"。
Thread.currentThread();//用于获取执行当前方法的线程

public class CurrentThreadDemo {
    public static void main(String[] args) {
        Thread main = Thread.currentThread();//用于获取执行当前方法的线程
        System.out.println("主线程:"+main);
        dosome();//主线程调用dosome方法
    }

    public static void dosome(){
        Thread t = Thread.currentThread();
        System.out.println("执行dosome方法的线程是:"+t);
    }
}

线程提供了一套获取相关信息的方法

public class ThreadInfoDemo {
    public static void main(String[] args) {
        Thread main = Thread.currentThread();//获取主线程进行查看

        String name = main.getName();//获取线程的名字
        System.out.println(name);

        long id = main.getId();//获取线程的唯一标识
        System.out.println(id);

        //priority:优先级
        int priority = main.getPriority();//获取线程的优先级
        System.out.println(priority);

        //当前线程是否被中断了
        boolean isInterrupted = main.isInterrupted();
        System.out.println("是否被中断:"+isInterrupted);
        //是否为守护线程
        boolean isDaemon = main.isDaemon();
        System.out.println("是否为守护线程:"+isDaemon);
        //是否活着
        boolean isAlive = main.isAlive();
        System.out.println("是否活着:"+isAlive);

    }
}

1.线程池的相关概念和运用
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,threadFactory,RejectedExecutionHandler handler)

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出来：www" + i);
        }
    }
}

import java.util.concurrent.*;

//制作线程池
public class ThreadPollDemo {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService poll = new ThreadPoolExecutor(3, 5,
                6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        //给任务线程池处理
        Runnable target = new MyRunnable();
        poll.execute(target);
        poll.execute(target);
        poll.execute(target);
        //ArrayBlockingQueue
        poll.execute(target);
        poll.execute(target);
        poll.execute(target);
        poll.execute(target);
        poll.execute(target);
        //
        poll.execute(target);
        poll.execute(target);
        //
        poll.execute(target);
        poll.shutdownNow();//立刻关闭
        poll.shutdown();//等待跑完
    }
}

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n){
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum+=i;
        }
        return Thread.currentThread().getName();
    }
}

import java.util.concurrent.*;

//制作线程池
public class ThreadPollDemo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建线程池对象
        ExecutorService poll = new ThreadPoolExecutor(3, 5,
                6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        //给任务线程池处理
        Future<String> f1= poll.submit(new MyCallable(100));
        Future<String> f2= poll.submit(new MyCallable(500));
        Future<String> f3= poll.submit(new MyCallable(700));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
    }
}
//相关补充
Runnable没有返回值，而实现callable接口的任务线程能返回执行结果
Callable接口实现类中的run方法允许异常向上抛出，可以在内部处理，try catch，但是runnable接口实现类中run方法的异常必须在内部处理，不能抛出 

 Executors实现线程池//静态方法直接调用

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo3 {
    public static void main(String[] args) {
        //创建固定线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());//已经没有多余任务
    }
}

 大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

时间定时器

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
//普通的时间计时
public class TimerDemo1 {
    public static void main(String[] args) {
        //创建Timer定时器
        Timer timer = new Timer();//定时器本身就是一个单线程
        //调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行AA"+new Date());
                System.out.println(10/0);//有异常，后面任务就不运用了
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },0,2000);//long delay延迟时间,long period之后的输出时间

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行BB");
            }
        },0,2000);
    }
}

import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
//线程池计时器
public class ThreadDemo2 {
    public static void main(String[] args) {
        //创建ScheduledExectorService线程池
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
        //开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        },0,2, TimeUnit.SECONDS);//long initialDelay初始延迟，long period延迟
        //不影响其他的进程，即使有进程异常也不会影响其他的进程
    }
}

并行与并发的含义
并发：CPU分时轮询的执行线程。
并行：同一个时刻同时在执行。

线程的状态
线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。
理解线程的状态有利于提升并发编程的理解能力。​​​​​​​
线程的6种状态