Java基础7：多线程_线程不占用堆空间一个只能创建一个线程线程是处理器任务调度和执行-CSDN博客

本文链接：https://blog.csdn.net/wangwangnvzi/article/details/115772715
                    
                        
                    
                    程序、进程、线程 
程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指段静态的代码，静态对象。
进程(process) 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程（即生命周期）。 
  程序是静态的，进程是动态的
进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
 
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 
  若一个进程同一时间并行执行多个线程，就是支持多线程的
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，拥有共同的方法区和堆空间，线程切换的开销小
一个进程中的多个线程共享相同的内存单元/内存地址空间，它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
 
单核CPU与多核CPU 
  单核CPU，其实是一种假的多线程，因为在一个时间单元内，一个CPU也只能执行一个线程的任务。CPU通过调度交替执行这些线程，动态规划这些线程的执行。但由于CPU效率高，时间单元特别短，交替执行线程也感觉不出来。
多核CPU，能同时执行多个线程，更好的发挥多线程的效率。
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
 
串行、并行、并发 
  串行：一个CPU，一个任务一个任务地处理
并行：多个CPU，同时执行多个任务
并发：一个CPU，交替执行不同任务
并行与并发的判断，往往跟是否有多个CPU、多个任务有关，而与程序是否是多线程无关。一个程序有两个及以上的线程，只有一个CPU，两个线程交替在一个CPU中执行，此时是并发；如果此时有多个CPU，能够同时运行多个线程，此时是并行；如果这些线程必须在一个CPU上一个一个执行，而不能交替，此时是串行
 
 


   并行与并发 
 
 
多线程的优点
 以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
 
提升高优先级应用程序的响应速度。对图形化界面更有意义，可增强用户体验。
提高计算机系统CPU的利用率，交替执行意味着空挡更小
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和
 修改
 
多线程的应用场景 
  程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。
 
 
线程的创建和使用 
thread类介绍 
  Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现
构造器： 
    Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口以及run方法
Thread(Runnable target, String name)：在上一个基础上给线程赋名
 
常用方法： 
    start(): 启动线程，JVM调用该对象的run()方法
run(): 继承Thread的类通常需要重写此方法，该方法是线程在被调度时执行的操作
getName(): 返回线程的名称
setName(String name):设置该线程名称
currentThread(): 静态方法，返回执行当前代码线程
yield()：使线程让步，线程进入runable状态，与其他线程一同竞争CPU执行权，不一定换其他线程执行，也有可能该线程再次抢到CPU执行权
join() ：在线程A中用线程B调用join()方法，此时A进入阻塞状态，CPU执行B，直到B完全执行后，线程A结束阻塞状态。join方法不会让所有线程阻塞，只会阻塞执行了B.join()语句的线程，其他线程不受影响
sleep(long millis)：(指定时间:毫秒)令当前活动线程在指定时间内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。使用时会抛出编译时异常InterruptedException
stop(): 强制线程生命期结束，已过时，不推荐使用
isAlive()：返回boolean，判断线程是否还活着
 
 
线程创建方式之一：继承Thread 
  定义子类继承Thread类
子类中重写Thread类中的run方法
创建Thread子类对象，即创建了线程对象
调用线程对象start方法；该方法会启动线程，由JVM调用该线程的run方法
注意点： 
    要启动一个新线程，必须要调用start方法，而不是直接调用run方法；直接调用run方法的话，就只是调用一个普通方法，没有多线程
一个线程对象只能start一次，如果一个已经启动的线程再调用一次start方法会运行时报错，IllegalThreadStateException
多个线程的调用、执行过程都由CPU调度决定
 public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("New Thread");
        myThread.start();//输出New Thread
        System.out.println(Thread.currentThread().getName());//输出main
        //myThread.run();
		//如果直接调用run而不调用start，此时不会报错，但输出的是main
		//myThread.start();
		//如果连续两次调用start，运行时报错，IllegalThreadStateException
    }
}
class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
}
 
 
线程的优先级 
  Java的调度方式：同优先级线程组成先进先出队列（先到先服务），使用时间片策略；对高优先级，使用优先调度的抢占式策略（高优先级抢占CPU）
线程的优先级等级，Thread类中内置三个全局常量优先级等级 
    MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5
 
获取和设置优先级： 
    getPriority() ：返回线程优先级
setPriority(int newPriority) ：设置线程的优先级
 
说明： 
    线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
 
 
线程的创建方式之二： 
  定义子类，实现Runnable接口
子类中重写Runnable接口中的run方法
通过Thread类含参构造器创建线程对象
将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
调用Thread类的start方法：开启线程，JVM调用Thread对象的run方法，该run方法中又调用Runnable子类接口的run方法//Thread类部分源码
//Thread类中含有Runnable类型的属性
private Runnable target;
public Thread(Runnable target) {
	//当使用形参为Runnable的构造器时，会把参数赋给属性
	this(null, target, "Thread-" + nextThreadNum(), 0);
}
public void run() {
	if (target != null) {
		//系统发现target不为null，就调用target中的run方法，也就是创建Thread类时传入的
		//实现了Runnable接口的类中重写了的run方法
    	target.run();
	}
}
 
 
继承方式和实现方式的联系与区别 
  开发中优先使用实现Runnable接口的方式 
    实现的方式避免了单继承的局限性
实现的方式，多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理共享资源。
 
联系： 
    Thread类是实现了Runnable接口public class Thread implements Runnable
两者都需要实现run方法，将线程的操作声明在run方法中
 
 
线程的分类 
  Java中的线程分为两类：一种是守护线程，一种是用户线程
它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。当存在任意一个用户线程未离开，JVM不会离开；如果只剩下守护线程未离开，JVM将离开（退出）
守护线程是用来服务用户线程的，优先级较低。Java默认是用户进程，可以通过在start()方法前调用thread.setDaemon(true)将进程设置未守护进程
Java垃圾回收就是一个典型的守护线程
 
 
线程的声明周期 
JDK中用Thread.State类（Thread中的内部类）定义了线程的几种状态 
  新建（New）： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪（Runnable）：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行（Running）：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞（Blocked）：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡（Dead）：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
 
 


   线程五种状态转换 
 
 
线程的同步 
多线程的问题 
  多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
 class Ticket implements Runnable {
	private int tick = 100;
	public void run() {
		while (true) {
			if (tick > 0) {
				System.out.println(Thread.currentThread().getName() + "售出车票，tick号为：" + tick);
				tick--;
			} else
				break;
		}
	}
}
class TicketDemo {
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		t1.setName("t1窗口");
		t2.setName("t2窗口");
		t3.setName("t3窗口");
		t1.start();
		t2.start();
		t3.start();
	}
}
 
  以三个窗口共卖100张票为例，上述代码非常又可能出现重票、错票的情况。如：当只剩最后一张票时，一个窗口进行售票，判断了ticket>0后，此时没有下一步操作且发生了阻塞；另一个窗口也进行售票，此时由于第一个窗口没有操作阻塞了，第二个窗口也能通过ticket>0的判断，如果第二窗口也阻塞而第三个窗口也进入售票，那么会发生一样的情况，等阻塞小时候，三个窗口都会把票售出去，就发生了错票的情况
问题出现的原因：当多条语句在操作同一个共享的数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决方法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
 
Java中线程问题的解决办法：Synchronized的使用方法 
  解决办法之一：同步代码块synchronized(同步监视器){
	//需要被同步的代码
}
 
    操作共享数据的代码即为需要被同步的代码
被同步的代码包括少了，解决不了线程安全问题；被同步的代码包含少了，有可能会达不到多线程的效果
同步监视器指的是锁，任何一个类的对象都可当锁。但是多个线程必须公共同一把锁，即用同一个对象才能产生效果
对于实现方式，可以使用this充当锁；对于继承方式，可以使用继承类.class，用该类（类也是一种对象）来充当锁。因为实现方式的多线程通常只新建一个实现类对象，用this来表示同一个实现类对象，而继承方式通常需要新建多个类，此时用this保证不了是同一个对象
 class Ticket implements Runnable {
	private int tick = 100;
	public void run() {
		while (true) {
			//如果synchronized包含了while(true)，那么票永远只会被一个窗口售完
            synchronized(this){
                if (tick > 0) {
                    System.out.println(Thread.currentThread().getName() + "售出车票，tick号为：" + tick);
                    tick--;
                } else
                    break;
            }
		}
	}
}
class TicketDemo {
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		t1.setName("t1窗口");
		t2.setName("t2窗口");
		t3.setName("t3窗口");
		t1.start();
		t2.start();
		t3.start();
	}
}
 
解决办法之二：同步方法 
    public synchronized void method(){}
同步方法仍然有同步监视器，但不需要显式地声明
对于非静态方法，同步监视器是this；对于静态方法，同步监视器是当前类本身。对于实现方式和继承方式需要考虑方法是否静态，一般实现方式是非静态方法，继承方式是静态方法
 
有关同步监视器的释放的操作 
    会释放同步监视器的操作 
      当前线程的同步方法、同步代码块执行结束
当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
 
不会释放同步监视器的操作 
      线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
 
 
解决办法之三：Lock锁（JDK5.0新增） 
    从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
 class A{
	private final ReentrantLock lock = new ReenTrantLock();
	public void m(){
		lock.lock();
		try{
			//保证线程安全的代码;
		}
		finally{
			lock.unlock(); 
		}
	}
}
 
同步的优劣 
    优：解决了线程安全问题
劣：对于涉及共享数据的操作代码，相当于是一个单线程的过程，效率更低
 
synchronized和Lock的异同 
    Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：Lock、同步代码块（已经进入了方法体，分配了相应资源）、同步方法（在方法体之外）
 
 
线程安全的懒汉式单例模式class Singleton {
	// 1.私有化构造器
	private Singleton() {
	}
	// 2.内部提供一个当前类的静态化的实例，且没有初始化
	private static Singleton single;
	// 3.提供公共的静态的方法，返回当前类的对象
	public static Singleton getInstance() {
		//方式一：效率稍差
		//synchronized(Singleton.class){
		//	if(single == null) {
		//		single = new Singleton();
		//	}
		//	return single;
		//方式二：效率高
		if (single == null){
		//只有初始未null的状态下才有可能线程不安全，new了多个对象
		//当第一次执行完成不为null时，没必要再锁住了
			synchronized(Singleton.class){
				if(single == null) {
					single = new Singleton();
				}
			}
		}
		return single;
		}
	}
}
 
死锁问题 
  不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
解决方法：1.专门的算法、原则；2.尽量减少同步资源的定义；3.尽量避免嵌套同步
 
 
线程的通信 
wait()、notify()、notifyAll() 
  wait()：令当前线程挂起并放弃CPU、同步资源并等待，释放同步监视器。等候其他线程调用notify()或notifyAll()方法唤醒该线程，唤醒后等待重新获得对监视器的所有权后才能继续从断点处执行
notify()：唤醒一个被wait的线程，优先唤醒排队等待同步资源的线程中优先级最高者
notifyAll ()：唤醒所有被wait的线程
说明： 
    三个方法必须使用在同步代码块或同步方法中
三个方法必须由同步代码块或同步方法中的同步监视器对象调用，否则运行时报错：IllegalMonitorStateException
三个方法定义在Object类中
 
wait()与sleep()的异同 
    相同点：一旦执行都可以使得当前线程进入阻塞状态
不同点： 
      声明位置不同，sleep()声明在Thread类中，wait()声明在Object类中
调用条件不同，sleep()可以在任何场景下使用，wait()必须在同步代码块或同步方法中调用
sleep()不会释放同步监视器，wait()会释放同步监视器
 
 
 
例题：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。class Clerk { // 售货员
	private int product = 0;
	public synchronized void addProduct() {
		if (product >= 20) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			product++;
			System.out.println("生产者生产了第" + product + "个产品");
			notifyAll();
		}
	}
	public synchronized void getProduct() {
		if (this.product <= 0) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("消费者取走了第" + product + "个产品");
			product--;
			notifyAll();
		}
	}
}
class Productor implements Runnable { // 生产者
	Clerk clerk;
	public Productor(Clerk clerk) {
		this.clerk = clerk;
	}
	public void run() {
		System.out.println("生产者开始生产产品");
		while (true) {
			try {
				Thread.sleep((int) Math.random() * 1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.addProduct();
		}
	}
}
class Consumer implements Runnable { // 消费者
	Clerk clerk;
	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}
	public void run() {
		System.out.println("消费者开始取走产品");
		while (true) {
			try {
				Thread.sleep((int) Math.random() * 1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.getProduct();
		}
	}
}
public class ProductTest {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Thread productorThread = new Thread(new Productor(clerk));
		Thread consumerThread = new Thread(new Consumer(clerk));
		productorThread.start();
		consumerThread.start();
	}
}
 
 
JDK5.0新增线程创建方式 
新增方式之一：实现Callable接口 
  与使用Runnable相比， Callable功能更强大些：1.相比run()方法，可以有返回值；2.方法可以抛出异常；3.支持泛型的返回值；4.需要借助FutureTask类，比如获取返回结果
Future接口介绍 
    可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
 
Callable使用方法 
    1.创建一个实现Callable接口的实现类
2.重写call()方法，将线程需要的操作声明在call()方法中
3.创建Callable实现类的对象
4.将Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象
5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象（FutureTask实现了Runnable接口）
6.利用Thread对象调用start()方法，启动线程
7.可以用FutureTask对象调用方法来获取call()的返回值等
 import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
    public static void main(String[] args) {
    	//3.创建Callable实现类的对象
        MyCallableThread myCallableThread = new MyCallableThread();
        //4.将Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象
        FutureTask futureTask = new FutureTask(myCallableThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象
        Thread thread = new Thread(futureTask);
        //6.利用Thread对象调用start()方法，启动线程
        thread.start();

        try {
        	//7.可以用FutureTask对象调用方法来获取call()的返回值等
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//1.创建一个实现Callable接口的实现类
class MyCallableThread implements Callable{
    @Override
    //2.重写call()方法，将线程需要的操作声明在call()方法中
    public Object call() throws Exception {
        System.out.println("this is callable thread");
        return 1;
    }
}
 
 
新增方式之二：线程池 
  背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
解决思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
好处： 
    提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理 
      corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
 
 
线程池相关API： 
    JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor 
      void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
<T> Future <T> submit(Callable task)：执行任务，有返回值，一般用来执行Callable
void shutdown() ：关闭连接池
 
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池 
      Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
 
 
线程池的使用 
    1.提供指定线程数量的线程池
2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
3.关闭连接池
 class MyCallableThread implements Callable{
public class CallableTest {
    public static void main(String[] args) {
    	//1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //需要管理连接池，要强转成ThreadPoolExecutor
		//ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
		//service1.setCorePoolSize(15);
		//service1.setKeepAliveTime();
        //2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.submit(new MyCallableThread());
        //3.关闭连接池
        service.shutdown();
    }
}
    @Override
    public Object call() throws Exception {
        System.out.println("this is callable thread");
        return 1;
    }
}
 
 

                