多线程(自用)

线程基础

并发：一个时间节点只可以执行一件事情，例子：我们在吃饭时，有人打电话来，我停下吃饭的动作，去接电话，然后接着吃饭。
并行：一个时间节点可以同时解决几件时间，例子：我们吃饭时，有人打电话来，我边吃饭边接电话。
多任务处理有两种类型：
–基于进程
–基于线程

进程：一种自包容的运行程序，由操作系统直接管理，直接运行，有自己的地址空间，每个进程一开启都会消耗内存。

线程：是进程内部单一的顺序控制流，一个进程拥有多个线程。多个线程共享一个进程的内存空间。

多线程：在一个程序启动之后，我们可以在这个进程中开启多个执行空间，每个空间独立负责属于自己的功能，而这些独立的运行的空间称为线程，而多个线程处于一个进程中。那么这时我们就称当前这个程序是一个多线程的程序。
程序采用多线程的目的是为了提供程序的执行效率。

多线程运行的原理：程序运行最终需要CPU，而CPU在执行某个程序的时候，它在某个时间点上其实只能执行某个线程。而CPU它可以在多个线程之间做着高速的切换。由于切换的速度太快了，导致我们人肉眼根本无法看到多个程序之间的停顿。CPU的切换，是由CPU中的时间晶片决定。而我们认为无法控制。

主线程：main方法一运行，就开启主线程。
特点：
1、最先开始
2、最后结束
3、产生其他子线程
4、回收资源

线程创建的三种方式：
继承Thread类的子类，并覆盖run()方法。

class Man extends Thread{
	@Override
	public void run() {
		//线程代码
	}
}

实现Runnable接口的类，并实现run()方法。

class Man implements Runnable{
	public void run() {
		//线程代码
	}
}

使用Callable和Future创建线程---------------------
Callable接口提供了一个call（）方法作为线程执行体，所以我们要实现call方法，call()方法可以有返回值，call()方法可以声明抛出异常。

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

package com.thread;
 
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class CallableThreadTest implements Callable<Integer>
{

	public static void main(String[] args)
	{
		CallableThreadTest ctt = new CallableThreadTest();
		FutureTask<Integer> ft = new FutureTask<>(ctt);
		for(int i = 0;i < 100;i++)
		{
			System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
			if(i==20)
			{
				new Thread(ft,"有返回值的线程").start();
			}
		}
		try
		{
			System.out.println("子线程的返回值："+ft.get());
		} catch (InterruptedException e)
		{
			e.printStackTrace();
		} catch (ExecutionException e)
		{
			e.printStackTrace();
		}
 
	}
 
	@Override
	public Integer call() throws Exception
	{
		int i = 0;
		for(;i<100;i++)
		{
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
		return i;
	}
 
}

--------------------- 
作者：longshengguoji 
来源：CSDN 
原文：https://blog.csdn.net/longshengguoji/article/details/41126119 
版权声明：本文为博主原创文章，转载请附上博文链接！

使用接口实现线程的优点
1、继承的局限性
在Java中只支持单继承，不支持多继承。如果一个类已经继承了其他的类，这时如果这个类中有某些代码需要线程去执行，那么这个类是无法再去继承Thraed类的。

这时Java就把类中的run方法进行了抽取。Thread类是描述线程的，在Thread类中应该定义的所有功能都是和线程的操作相关的。早期的Thread类中的有个run方法，而这个run方法并不是操作线程的。run方法是让线程在开启执行需要执行的任务代码。
在Java中把操作线程的功能和线程要执行的任务功能写在一起，这样导致操作的功能和任务的功能严重耦合在其一起。于是就把run方法从Thread进行抽取，保存在Runnable接口中。

2、接口的功能
接口的功能：1、给事物体系增强扩展功能（额外功能）；2、给事物双方定义规则。

Runnable接口属于定义规则，定义了如何去书写线程的任务的规则。当后期开发人员需要操作线程的任务时，我们书写的代码就必须去实现Runnable接口，这样我们的程序就按照Runnable接口的规则中定义的功能把线程的进行明确。然后后期我们在创建线程时，就可以把这个任务交给线程。

启动线程调用start方法。

调用线程类中的start方法和run方法的区别：
调用start方法，是启动线程。会在主线程之外，开启新的子线程。多个线程交替执行。
调用run方法，是普通方法的调用。不会开启新的子线程。会在一个方法执行完毕后执行其他方法。

线程的状态

新建：通过new的方式产生新对象。
就绪：start启动，运行run方法。
运行：执行run()方法。
睡眠：调用线程sleep()方法。
等待：调用Object中的wait()方法。
挂起：调用yield()方法，线程显示让出CPU控制权。
阻塞：等待IO事件输入。
死亡：线程run方法执行完毕。

线程同步

线程不同步：当有多个线程在同时执行的时候，而且它们操作了共享的数据。这时由于cpu在多个线程之间进行切换，而操作共享的数据的代码并没有完全把操作共享数据的代码运行结束，cpu就切换到其他的线程上。这样就会导致共享数据出现错乱。就发生了线程的安全问题。线程不同步的本质是CPU在多个线程之间进行切换造成的。

线程同步：当两个或两个以上的线程同时访问同一个资源时，为了避免线程混乱，只允许同一时间一个线程访问。

任何进行线程同步：
使用synchronized关键字进行同步。或者使用lock接口进行同步。

主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。Lock的锁定是通过代码实现的，而synchronized是在JVM层面上实现的，synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。。Lock锁的范围有局限性，块范围，而synchronized可以锁住块、对象、类

线程优先级：当两个或两个以上线程处于就绪状态时，优先级高的线程会优先得到CPU的执行。优先级共有10级，数字越大，优先级越高。默认优先级为5。
在Thread类中使用getPriority() 获取线程游戏机，使用setPriority(int newPriority) 更改线程优先级。

线程变量

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最终的值。

死锁

一个对象进入对象ObjA上的监视器，而另一个线程进入对象ObjB上的监视器。如果ObjA中的线程试图调用ObjB上的任何synchronized方法，就将发生死锁。

解决死锁方法：notifyAll()方法唤醒全部线程或是使用Lock接口中提供的lock方法获取锁，unlock方法释放锁。

wait和sleep的区别：
1、sleep方法在线程类Thread类中定义。wait方法在Object中定义。
2、wait方法只能放在同步方法或同步块中，表示当前线程对资源进行等待。sleep方法可以在任何位置，
表示当前线程休眠。
3、wait方法要释放锁对象，sleep方法不会是释放对象锁。
4、wait方法使用后，线程需要notify唤醒后才能继续执行，而sleep在休眠结束后，线程自动继续执行。