Java多线程

1.概念

• 程序：是为了完成指定任务，用某种语言编写的一组指令的集合，即一段静态的代码。
• 进程：是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生，运行，和消亡的过程。
  如：运行中的QQ、微信，程序是静态的，但运行是动态的。
• 线程：进程可进一步细化为线程，是一个程序内部的一个执行路径。
  例如：QQ可以同时发送消息聊天，听QQ音乐，下载聊天内容等，这些功能就是多线程的提现

2.创建新线程的方式

import java.util.concurrent.*;

/**
 * 创建线程的两种方式
 * |-----继承Thread类，重新run方法，调用子类的start方法
 * |-----实现runnable接口，重写run方法，new Thread(runnable).start
 * |-----实现Callable接口配合FutureTask
 * |-----线程池创建线程
 */
@SuppressWarnings("all")
public class Thread1 {
    public static void main(String[] args) {
        /**
         * 继承Thread类新建线程
         */
        NewThread newThread = new NewThread();
        newThread.start();

        /**
         * 实现runnable接口新建线程
         */
        Thread thread = new Thread(new NewThread1());
        thread.start();

        /**
         * 匿名类的方式创建新线程
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程3");
            }
        }).start();

        /**
         * lambda表达式方式创建新线程
         */

        Runnable runnable = () -> System.out.println("线程4");
        Thread thread1 = new Thread(runnable);
        thread1.start();

        /**
         * 实现Callable接口配合FutureTask创建新线程
         */
        NewThread2 callable = new NewThread2();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread2 = new Thread(futureTask);
        thread2.start();
        try {
            Integer num = futureTask.get();
            System.out.println(num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        /**
         * lambda表达式创建callable方式线程
         *
         */

        Callable<Integer> callable1 = () ->300 ;
        FutureTask<Integer> futureTask1 = new FutureTask<>(callable1);
        new Thread(futureTask1).start();
        try {
            Integer num1 = futureTask1.get();
            System.out.println(num1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        /**
         * 通过线程池方式创建
         * jdk5.0之后提供了创建线程池的方式
         */

        Runnable runnable1 = () -> System.out.println("线程池创建的线程");
        Callable<String> callable2 = () ->"110";
        ExecutorService executorService = Executors.newFixedThreadPool(2);
//        executorService.submit(runnable1);
        Future<String> future = executorService.submit(callable2);
        try {
            String s = future.get();
            System.out.println(s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }


    }
}

class NewThread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("线程1");
    }
}

class NewThread1 implements Runnable{

    @Override
    public void run() {
        System.out.println("线程2");
    }
}

class NewThread2 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;

        for (int i = 0; i <= 100; i++) {
            sum += i;
        }

        return sum;
    }
}

3.线程常用方法

/**
 * Thread类的常用方法的测试
 * 1.run():Thread的子类一定要重写的方法。将此分线程要执行的操作，声明在run()中
 * 2.start():要想启动一个分线程，就需要调用start():①启动线程②调用线程的run()
 * 3.currentThread():静态方法，获取当前的线程
 * 4.getName():获取当前线程的名字
 * 5.setName(String name)：设置当前线程的名字
 * 6.yield():当前线程调用此方法，释放CPU的执行权
 * 7.join():在线程a中调用线程b的join()方法:只有当线程b执行结束以后，线程a结束阻塞状态，继续执行。
 * 8.sleep(long millitimes):让当前的线程睡眠millitimes毫秒
 * 9.isAlive():判断当前线程是否存活
 * 
 * 10.线程的优先级：
 *      MAX_PRIORITY：10
 *      NORM_PRIORITY：5 ---默认优先级
 *      MIN_PRIORITY：1
 * 
 *   设置优先级：setPriority(int priority); 
 *   获取优先级：getPriority();
 *   
 *   设置优先级以后，对高优先级，使用优先调度的抢占式策略，抢占低优先级的执行。但是并不意味着高优先级的线程一定先于低
 *   优先级的线程执行，而是从概率上来讲，概率更大而已。
 * 
 * 
 * 线程通信：wait() / notify() / notifyAll()  ---->java.lang.Object类中定义的方法
 * 
 */
class NumberThread extends Thread{
     public void run() {
     }
     
}



public class ThreadMethodTest {
    public static void main(String[] args) {
        NumberThread t1 = new NumberThread();

        //getName():获取当前线程的名字
        System.out.println(Thread.currentThread().getName());

        Thread.currentThread().setName("新线程");

        System.out.println(Thread.currentThread().getName());

        System.out.println(Thread.currentThread().getPriority());

        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);

        System.out.println(Thread.currentThread().getPriority());

        System.out.println(Thread.currentThread().isAlive());

        t1.start();

        System.out.println(t1.getName());
        System.out.println(t1.getPriority());


    }
}