java多线程较简单：1 创建线程的4种方式

1 什么是程序？

• 为了完成某些特定的任务，使用某种语言，编写一组指令的集合。如360软件

2 什么是进程？

• 个正在进行中的程序。如360打开了

3 什么是线程？

• 在一个进程中执行的一套功能流程，称为线程在一个进程中执行的一套功能流程，称为线程，如360打开了杀毒功能
• 在一个进程中执行的多套功能流程，称为多线程，如360打开了杀毒，下载等等的功能。

创建线程的方式一：

• 继承Thread类重新run方法然后start方法启动但是必须new出来实例启动不能启动多个线程共享数据

class Test1 extends Thread {
    @Test
    public void test1() {
        new Test1().start();
    }

    @Override
    public void run() {
        System.out.println("继承Thread类创建线程");
    }
}

创建线程的方式二：

• 实现runnable接口重写run方法可以启动多个线程共享数据

class Test2 implements Runnable {
    private static int i = 100;

    @Test
    public void test2(){
        new Thread(new Test2()).start();
        new Thread(new Test2()).start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":" + ++i);
    }
}

创建线程的方式三：

/*
 * 一、创建执行线程的方式三：实现 Callable 接口。 相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常。
 *
 * 二、执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。  FutureTask 是  Future 接口的实现类，这是闭锁的 一条线程运行代码一条线程用于接受运算结果
 */
public class TestCallable {

    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();

        //1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
        FutureTask <Integer> result = new FutureTask <>(td);


        new Thread(result).start();
        try {
            //2.接收线程运算后的结果
            Integer sum = result.get();  //FutureTask 可用于 闭锁

            System.out.println(sum);
            System.out.println("------------------------------------");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

}

class ThreadDemo implements Callable <Integer> {


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

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

        return sum;
    }

}

创建线程的方式四：

• 一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。

• 二、线程池的体系结构：
  java.util.concurrent.Executor : 负责线程的使用与调度的根接口
  |ExecutorService 子接口: 线程池的主要接口|–**ExecutorService 子接口: 线程池的主要接口
  　 |–ThreadPoolExecutor 线程池的实现类|–ThreadPoolExecutor 线程池的实现类
  　　　|–ScheduledExecutorService 子接口：负责线程的调度 |–ScheduledExecutorService 子接口：负责线程的调度
  　　　|–ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor， 实现 ScheduledExecutorService

三、工具类 : Executors
ExecutorService newFixedThreadPool() : 创建固定大小的线程池
ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程

ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。

创造newFixedThreadPool()执行任务共三步
1 创建线程池
2 为线程池分配任务
3 关闭线程池

public class TestThreadPool {

	public static void main(String[] args) throws Exception {
		//1. 创建线程池
		ExecutorService pool = Executors.newFixedThreadPool(5);

		ThreadPoolDemo tpd = new ThreadPoolDemo();

		//2. 为线程池中的线程分配任务
		for (int i = 0; i < 10; i++) {
			pool.submit(tpd);
		}

		//3. 关闭线程池
		pool.shutdown();
	}
}

class ThreadPoolDemo implements Runnable{

	private int i = 0;

	@Override
	public void run() {
		while(i <= 100){
			System.out.println(Thread.currentThread().getName() + " : " + i++);
		}
	}
}

也可以实现callable< T >接口用来接受结果集

public class TestThreadPool {

	public static void main(String[] args) throws Exception {
		//1. 创建线程池
		ExecutorService pool = Executors.newFixedThreadPool(5);

		List<Future<Integer>> list = new ArrayList<>();

		for (int i = 0; i < 10; i++) {
			Future<Integer> future = pool.submit(new Callable<Integer>(){

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

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

					return sum;
				}

			});

			list.add(future);
		}

		pool.shutdown();

		for (Future<Integer> future : list) {
			System.out.println(future.get());
		}



		/*ThreadPoolDemo tpd = new ThreadPoolDemo();

		//2. 为线程池中的线程分配任务
		for (int i = 0; i < 10; i++) {
			pool.submit(tpd);
		}

		//3. 关闭线程池
		pool.shutdown();*/
	}

//	new Thread(tpd).start();
//	new Thread(tpd).start();
}


class ThreadPoolDemo implements Runnable{

	private int i = 0;

	@Override
	public void run() {
		while(i <= 100){
			System.out.println(Thread.currentThread().getName() + " : " + i++);
		}
	}
}

创造newScheduledThreadPool进行多条线程延迟执行

public class TestScheduledThreadPool {

    public static void main(String[] args) throws Exception {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);

        for (int i = 0; i < 5; i++) {
            Future <Integer> result = pool.schedule(new Callable <Integer>() {

                @Override
                public Integer call() throws Exception {
                    int num = new Random().nextInt(100);//生成随机数
//					int num=ThreadLocalRandom.current().  nextInt(100);
                    System.out.println(Thread.currentThread().getName() + " : " + num);
                    return num;
                }

            }, 1, TimeUnit.SECONDS);

            System.out.println(result.get());
        }

        pool.shutdown();
    }

}

线程的一些常用方法：

currentThread() : 获取当前线程
getName() : 获取线程名称
setName() : 设置线程名称
start() : 启动线程
sleep(long millis) : 是一个静态方法，使当前线程进入睡眠状态
join() / join(long millis) : 是一个实例方法，使当前线程进入阻塞状态
interrupt() : 中断阻塞状态的线程
isAlive() : 判断线程是否处于存活状态
yield() : 线程让步

线程的优先级(1-10)：默认的优先级为5. 优先级高并不意味着线程一定会优先执行
只不过更高概率的获取 cpu 资源。

getPriority() : 获取线程优先级
setPriority() : 设置线程优先级

MIN_PRIORITY : 1
NORM_PRIORITY : 5
MAX_PRIORITY : 10

线程的生命周期