多线程的概念：略
多线程的目的：提高效率
主线程：
package demo; //主线程 public class Demo { public static void main(String[] args) { function(); System.out.println(1); } public static void function(){ for (int i = 0; i < 10000; i++) { System.out.println(i); } } }
这段简单的代码，我们发现：
必须要先执行方法输出完10000次的数字后才可以打印第二行的数字1
那么有没有方法，可以做到在执行方法的同时执行第二行的输出？
Thread类
创建新线程的两种方法：
第一种：
package demo; public class SubThread extends Thread { //重写run方法 public void run(){ for(int i = 0 ; i< 50 ; i++){ System.out.println(i+"run"); } } }
package demo; public class ThreadDemo { public static void main(String[] args) { SubThread st1 = new SubThread(); st1.start(); for (int i = 0; i < 50; i++) { System.out.println(i+"main"); } } }
这里输出时候，发现打印的run和main随机出现，交错出现，而不像以前那样按顺序打印
原因：创建了新的线程，两条线程由cpu选择执行，我们无法控制
start方法开启新的线程，继承了Thread类因为只有继承了它才可以操作线程
重写run方法因为，Thread类本身没有写入有意义的run方法，相当于一个模板，供开发者使用
线程名：
每个线程都有自己的名字，主线程名：main，其他新建线程默认名：Thread-n
获取、修改线程名：
package demo1; public class NameThread extends Thread { public void run(){ System.out.println(super.getName()); //输出：默认是Thread-0，如果修改了，就是hello } }
package demo1; public class ThreadDemo { public static void main(String[] args) { NameThread nt1 = new NameThread(); nt1.setName("hello"); //修改线程名为hello，主线程不能改名 nt1.start(); Thread t = Thread.currentThread(); System.out.println(t.getName()); //输出：main } }
Thread类的一个实用方法：
package demo1; public class ThreadDemo { public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 10; i++) { Thread.sleep(1000); System.out.println(i); } //每次打印都会等待一秒，参数是毫秒值 } }
第二种创建线程方法：
package demo1; public class SubRunnable implements Runnable { public void run() { for (int i = 0; i < 50; i++) { System.out.println(i + "run"); } } }
package demo1; public class ThreadDemo { public static void main(String[] args) { SubRunnable sr1 = new SubRunnable(); Thread t1 = new Thread(sr1); t1.start(); for (int i = 0; i < 50; i++) { System.out.println(i + "main"); } } }
这种方式好处：
1.接口可以多实现，避免了单继承的局限性
2.线程和方法分离，更符合面向对象的特点
3.资源实现共享
这两种方式可以实用匿名内部类实现：
package demo1; public class ThreadDemo { public static void main(String[] args) { // 继承方式 new Thread() { public void run() { System.out.println("1"); } }.start(); // 实现接口方式 new Thread(new Runnable() { public void run() { System.out.println(2); } }).start(); } }
线程的状态：
1.新建状态：new Thread()创建线程对象
2.运行状态：使用了start()方法进入运行状态
3.退出状态：run方法结束，或者调用了stop方法（已过时，不建议实用）
4.阻塞状态：有时候使用了start方法，但不一定立即运行，或者运行之后CPU由于一些原因不再分配，由运行状态转到阻塞状态
5.休眠状态：前边提到的sleep方法就是这种状态，也有可能转到阻塞状态或者运行状态
6.等待状态：wait方法，无限等待，notify方法可以唤醒线程，可能转到运行或阻塞状态
注意：受阻塞是等待CPU的资源，休眠等待是放弃CPU的执行
线程池的概念：
一个容器，存入多个线程，需要时候，拿出执行，
运行结束后线程再回到容器中，这种方式可以提高效率
实现线程池：
package demo1; public class ThreadPoolRunnable implements Runnable { public void run(){ System.out.println(Thread.currentThread().getName()+"线程提交任务"); //输出: pool-1-thread-1线程提交任务 // pool-1-thread-2线程提交任务 }
package demo1; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolDemo { public static void main(String[] args) { //调用工厂类的方法创建线程池 ExecutorService es1 = Executors.newFixedThreadPool(2); es1.submit(new ThreadPoolRunnable()); es1.submit(new ThreadPoolRunnable()); //运行后不会停 es1.shutdown();//销毁线程池，不常用 } }
实现线程的Callable接口方式：
它弥补了Runnable方式的缺陷：无法抛出异常，并且有返回值
使用方法和Runnable方式基本一致：
示例：
package demo1; import java.util.concurrent.Callable; public class ThreadPoolCallable implements Callable<String>{ public String call(){ return "a"; } }
package demo1; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class ThreadPoolDemo { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService es1 = Executors.newFixedThreadPool(2); Future<String>f1 = es1.submit(new ThreadPoolCallable()); String s1 = f1.get(); System.out.println(s1); //得到返回值，输出a } }
简单应用：多线程异步计算
使用两个线程计算求和：
package demo1; import java.util.concurrent.Callable; public class GetSumCallable implements Callable<Integer> { private int a; public GetSumCallable(int a) { this.a = a; } public Integer call() { int sum = 0; for (int i = 0; i <= a; i++) { sum += i; } return sum; } }
package demo1; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class ThreadPoolDemo { public static void main(String[] args) throws Exception { ExecutorService es1 = Executors.newFixedThreadPool(2); Future<Integer> f1 = es1.submit(new GetSumCallable(100)); Future<Integer> f2 = es1.submit(new GetSumCallable(300)); System.out.println(f1.get()); System.out.println(f2.get()); es1.shutdown(); } }
