【Java基础】线程的概念、特点及创建线程的三种方式

线程概念

程序： 是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
进程： 是执行程序的一次执行过程，她是一个动态的概念，是系统资源分配的单位。正在运行的程序在内存中开辟相应的空间。
线程： 负责程序执行的一条执行路径，是CPU调度和执行的单位。

进程和线程的关系： 程的执行实际上是线程在执行，一个进程可以包含若干个线程，进程中至少有一个线程，不然没有存在的意义。

注意:很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下， 在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

普通方法调用和多线程

线程概念：
◆ 线程就是独立的执行路径；
◆ 在程序运行时，即使没有自己创建线程，后台也会有多个线程,如主线程，gc线程；
◆ main()称之为主线程，为系统的入口，用于执行整个程序；
◆ 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的；
◆ 线程不一定立即执行，cpu安排调度；
◆ 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
◆ 线程会带来额外的开销，如cpu调度时间，并发控制开销；
◆ 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

多线程特点

• 多线程实现了同时执行的效果（不同功能或相同功能的同时执行）。
  多线程不一定能提高效率，但能充分利用CPU，关键是实现了在一个程序中，不同功能或相同功能的同时执行的效果

• java程序是否是多线程程序：
  有一个负责执行main中代码的线程，就是主线程
  有一个负责垃圾回收的线程，垃圾回收线程

  垃圾回收线程：
  Object的finalize()方法，等垃圾收集器确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象

  强制执行垃圾回收线程：
  System.gc()运行垃圾回收线程，是一个守护线程，优先级低，主线程的其他代码优先运行，主线程结束时，即使它没有回收完，也要结束。

  

  多线程的运行结果是不确定的

• 线程执行的功能不同，则对应的功能代码所写的位置也不同
  1.主线程执行的功能代码写在main方法中
  2.垃圾回收线程执行的功能代码写在finalize方法中

  把线程执行的功能称为线程的任务
  线程的任务不同，则任务代码所写的位置不同

互不影响

每个线程在栈中都有自己的一块内存，各自执行自己的任务，当所有线程全部执行完，整个程序才结束。
一个线程发生异常只是线程自己的问题，不会影响其它线程。

创建线程的方式

一、继承 Thread 类

1. 自定义线程类继承Thread类，因为Thread是线程类，则这个子类也是线程类了；
2. 在子类中重写run方法 void run()，该子类创建的对象就是一个子线程，线程执行的任务代码需要书写在run方法中；
   （注：run方法是重写的方法，不能使用throws抛出异常，原方法没有）
3. 创建线程对象；
4. 调用**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 接口

1. 创建一个实现了Runnable接口的类（该类只需重写run方法，所以该类是专门用来定义线程执行的任务代码的）
2. 创建实现了Runnable接口的类的对象
3. 创建线程对象——使用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接口（了解即可）

1. 实现Callable接口，需要返回值类型

2. 重写call方法，需要抛出异常

3. 创建目标对象

4. 创建执行服务：

   ExecutorService service= Executors.newFixedThreadPool(3);

5. 提交执行：Future r1= service.submit(t1);

6. 获取结果：boolean rs3=r3.get();

7. 关闭服务：service.shutdownNow();

Callable的好处

1. 可以定义返回值
2. 可以抛出异常

利用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);