线程概念
程序： 是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
进程： 是执行程序的一次执行过程，她是一个动态的概念，是系统资源分配的单位。正在运行的程序在内存中开辟相应的空间。
线程： 负责程序执行的一条执行路径，是CPU调度和执行的单位。
进程和线程的关系： 程的执行实际上是线程在执行，一个进程可以包含若干个线程，进程中至少有一个线程，不然没有存在的意义。
注意:很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下， 在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。
普通方法调用和多线程
线程概念：
◆ 线程就是独立的执行路径；
◆ 在程序运行时，即使没有自己创建线程，后台也会有多个线程,如主线程，gc线程；
◆ main()称之为主线程，为系统的入口，用于执行整个程序；
◆ 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的；
◆ 线程不一定立即执行，cpu安排调度；
◆ 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
◆ 线程会带来额外的开销，如cpu调度时间，并发控制开销；
◆ 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。
多线程特点
-
多线程实现了同时执行的效果（不同功能或相同功能的同时执行）。
多线程不一定能提高效率，但能充分利用CPU，关键是实现了在一个程序中，不同功能或相同功能的同时执行的效果 -
java程序是否是多线程程序：
有一个负责执行main中代码的线程，就是主线程
有一个负责垃圾回收的线程，垃圾回收线程垃圾回收线程：
Object的finalize()方法，等垃圾收集器确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象强制执行垃圾回收线程：
System.gc()运行垃圾回收线程，是一个守护线程，优先级低，主线程的其他代码优先运行，主线程结束时，即使它没有回收完，也要结束。
多线程的运行结果是不确定的
-
线程执行的功能不同，则对应的功能代码所写的位置也不同
1.主线程执行的功能代码写在main方法中
2.垃圾回收线程执行的功能代码写在finalize方法中把线程执行的功能称为线程的任务
线程的任务不同，则任务代码所写的位置不同
互不影响
每个线程在栈中都有自己的一块内存，各自执行自己的任务，当所有线程全部执行完，整个程序才结束。
一个线程发生异常只是线程自己的问题，不会影响其它线程。
创建线程的方式
一、继承 Thread 类
- 自定义线程类继承Thread类，因为Thread是线程类，则这个子类也是线程类了；
- 在子类中重写run方法 void run()，该子类创建的对象就是一个子线程，线程执行的任务代码需要书写在run方法中；
（注：run方法是重写的方法，不能使用throws抛出异常，原方法没有） - 创建线程对象；
- 调用**start()**方法启动线程。
class Person extends Thread{
…………
public void run(){//任务
for(int i=1;i<=10;i++){
sop(Thread.currentThread().getName()+"…………"+i);
//线程默认的名字：Thread-编号（编号从0开始）
}
}
}
class Demo5{
public static void main(String[] args){ //主线程
Person ren1=new Person("张三");//创建了一个线程
Person ren2=new Person("李四");//创建了一个线程
//ren1.run(); //普通的方法调用，并没有启动线程
//启动线程，当线程抢到cpu时会执行run方法中的任务代码
ren1.start();
ren2.start();
sop(Thread.currentThread().getName());//主线程名字:main
}
}
不建议使用：避免OOP单继承局限性
卖票问题——四个窗口卖票：
创建四个线程，四个线程的任务都是卖票，只需要定义一个Thread的子类。
出现了一张票被卖了4次的问题，原因是每个Ticket对象中都有一个num成员。需要让四个线程共享50张票：把票修饰为static的，则票就只有一份了。
不是所有情况都能被修饰为static的，使用创建线程的第二种方式来解决。创建线程的第一种方式：
- Ticket类既是任务类也是线程类
四个线程需要创建四个Ticket对象，每个对象中都有一份儿资源，所以四个线程就有了四份儿资源创建线程的第二种方式：
- Ticket类只是任务类，只需创建Ticket的一个对象，只有一份儿资源
让四个线程都执行相同的任务
二、实现 Runnable 接口
- 创建一个实现了Runnable接口的类（该类只需重写run方法，所以该类是专门用来定义线程执行的任务代码的）
- 创建实现了Runnable接口的类的对象
- 创建线程对象——使用Thread类 Thread(Runnable target)
class Ticket implements Runnable {//任务类
private int num=50;
public void run(){
while(true)
if(num>0)
sop(Thread.currentThread().getName()+"…sale…"+(num--));
}
}
class Test implements Runnable{ public void run(){……} }
class Demo8 {
public static void main(String[] args) {
Ticket t=new Ticket(); //任务对象
Test tt = new Test();
//Thread是线程类，线程和任务分别面向对象，那么线程执行的任务不再是固定的了
Thread t1=new Thread(tt);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
Thread t4=new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();//new Thread(t).start();
}
}
Thread类实现了Rannable接口
- Thread(Runnable target)
class Test1 implements Runnable{
public void run(){
System.out.println("Hello World!");
}
}
class Test2 extends Thread{
public void run(){
System.out.println("Hello");
}
}
class Demo9{
public static void main(String[] args) {
//Test1 t1=new Test1();
//Thread tt = new Thread(t1);
//Test2 t2 = new Test2();
Thread t=new Thread(()->System.out.println("Hello"));
t.start();
}
}
推荐使用：避免单继承局限性，灵活方便，方便一个对象被多个线程使用
//一份资源 StartThread station = new StartThread(); //多个代理 new Thread(station,"小明").start(); new Thread(station,"小红").start(); new Thread(station,"老师").start();
对比
继承了Thread的类，既是线程类，同时也是任务类，用该类创建的线程执行的任务是固定的；
实现了Rannable接口的类是任务类，线程和任务分别面向对象，那么线程执行的任务不再是固定的了。
三、实现Callable接口（了解即可）
-
实现Callable接口，需要返回值类型
-
重写call方法，需要抛出异常
-
创建目标对象
-
创建执行服务：
ExecutorService service= Executors.newFixedThreadPool(3); -
提交执行：
Future<Boolean> r1= service.submit(t1); -
获取结果：
boolean rs3=r3.get(); -
关闭服务：
service.shutdownNow();
Callable的好处
- 可以定义返回值
- 可以抛出异常
利用Callable接口改造下载图片案例
package com.shan.demo4; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurrent.*; public class TestCallable implements Callable<Boolean> { public String url; public String name; public TestCallable(String url,String name){ this.url=url; this.name=name; } @Override public Boolean call() { //run方法线程体 WebDownloader webDownloader = new WebDownloader(); webDownloader.Downloader(url,name); System.out.println("下载的文件名为："+name); return true; } public static void main(String[] args) throws ExecutionException, InterruptedException { TestCallable t1 = new TestCallable("https://img-home.csdnimg.cn/images/20201124032511.png","3-1.png"); TestCallable t2 = new TestCallable("https://img-home.csdnimg.cn/images/20210910112431.gif","3-2.gif"); TestCallable t3 = new TestCallable("https://csdnimg.cn/release/blogv2/dist/pc/img/original.png","3-3.png"); //创建执行服务： ExecutorService service= Executors.newFixedThreadPool(3); //提交执行： Future<Boolean> r1= service.submit(t1); Future<Boolean> r2= service.submit(t2); Future<Boolean> r3= service.submit(t3); //获取结果： boolean rs1=r1.get(); boolean rs2=r2.get(); boolean rs3=r3.get(); //关闭服务： service.shutdownNow(); } } class WebDownloader{ public void Downloader(String url,String name){ try { FileUtils.copyURLToFile(new URL(url),new File(name)); } catch (IOException e) { e.printStackTrace(); System.out.println("IO异常，Downloader方法出现问题"); } } }方法二：利用FutureTask
//方法二： FutureTask<Boolean> futureTask=new FutureTask<>(new TestCallable("https://img-home.csdnimg.cn/images/20201124032511.png","1.png")); new Thread(futureTask).start(); Boolean aBoolean = futureTask.get(); System.out.println(aBoolean);