回来补基础，为以前偷的懒还债😄
多线程可以说是java的第一大特色了，所以肯定是要熟练掌握的。
-
进程与线程
首先得了解一下进程与线程。
进程：是指在系统之中的一个程序的执行周期
一块资源在同一个时间段上可能会有多个进程交替执行，但是在同一个时间点上只会有一个进程执行
线程：是指在进程基础上的进一步划分，也就是说线程是比进程更小的单位
线程的执行性能一定是比进程要高的，而java本身是一个多线程的编程语言 ，所以其执行性能一定很快
所谓的高并发就是线程量过高，造成服务器的内存不足无法处理新用户。
没有进程就没有线程。
多线程
要实现多线程，前提就是有一个线程的执行主类。
- 实现多线程的主类有两类途径：
- 继承Thread类(Thread类就是实现了Runnable的子类)
- [推荐]实现Runnable、Callable接口
- 继承Thread类
java.lang.Thread是一个线程线程操作的核心类。定义一个线程的主类，最简单的方法就是继承Thread类覆写run方法（相当于线程的主方法）
线程的执行从run方法开始
正确启动多线程的方法只有一个start()，线程的执行顺序时jiao'ti
public class Demo1 extends Thread{
Integer arrs[] = {1,2,3,4,5,6,7,8,9};
List<Integer> l = new ArrayList(Arrays.asList(arrs));
@Override
public void run() {
l.forEach(s -> System.out.println(s));
}
public static void main(String[] args) {
new Demo1().start();
new Demo1().start();
new Demo1().start();
}
}
可以看出多个线程不是按照顺序来执行，而是通过抢占资源来进行交替执行image.png
每一个线程对象只能启动一次，如果重复启动一个线程对象则会抛出异常“java.lang.IllegalThreadStateException”
image.png
- 实现Runnable接口
Thread类的核心功能就是进行线程的启动，但是平时开发是不推荐使用继承Thread这种方式，因为这样会造成单继承局限，在java中是可以多实现的，所以推荐使用实现Runnable接口这种方式
实现Runnable，覆写run方法。
使用这种方式虽然解决了单继承的问题但是又有了一个新问题，那就是实现Runnable是没有start方法的，那么此时就需要关注Thread类提供的构造方法“ public Thread(Runnable target)”，可以接收实现了Runnable的类，所以实现Runnable这种方式的线程启动方法则是通过Thread类来启动
public class Demo1 implements Runnable{
Integer arrs[] = {1,2,3,4,5,6,7,8,9};
List<Integer> l = new ArrayList(Arrays.asList(arrs));
@Override
public void run() {
l.forEach(s -> System.out.println(s));
}
public static void main(String[] args) {
Demo1 d1=new Demo1();
new Thread(d1).start();;
}
}
多线程的启动永远都是通过Thread类的start方法来进行启动
平时开发中最常见的就是这种匿名内部类的方式了吧
public class Demo1{
public static void main(String[] args) {
Integer arrs[] = {1,2,3,4,5,6,7,8,9};
List<Integer> l = new ArrayList(Arrays.asList(arrs));
Demo1 d1=new Demo1();
new Thread(() -> {
l.forEach(s -> System.out.println(s));
}).start();
}
}
线程的运行状态
线程的启动使用的是start()，但是并不意味着调用了start()就立刻启动了，而是进入到就绪状态，等待进行调度后执行，需要将资源分配给线程运行后才可以执行多线程中的代码（run中的代码）运行状态，当执行了一段时间之后或者遇到了导致线程阻塞的事件阻塞状态， 线程需要让出资源，让其他线程来继续执行，这个时候的run方法可能还没执行完只执行了一半，重新进入到就绪状态，重新等待分配新资源，再继续执行。当线程执行完毕后才会进入到终止状态。
- Callable实现多线程
- 从jdk1.5开始追加了一个新的开发包：java.util.concurrent，这个开发包主要是进行高性能编程。里面会提供一些高并发操作中才会使用的类。在这个包里定义有一个新的接口：Callable<V>
- Callable和Runnable相比Callable多了个泛型。虽然Runnable的run方法也是线程的主方法，但是其是没有返回值的，因为它的设计是遵循了主方法main的设计原则。 Callable这个泛型是用来定义返回值类型（设计初衷就是线程开始了就别回头）
- 但是很多时候需要一些返回值，比如某些线程完成之后可能带来一些返回结果，这种情况就可以利用Callable来实现多线程。
下面是一段使用 Callable的代码，平时用的比较多的还是Runnable
public class Demo1 implements Callable<String> {
public static void main(String[] args)throws Exception {
FutureTask<String> task = new FutureTask(new Demo1());
new Thread(task).start();;
System.out.println(task.get()); // 需要抛出异常
}
@Override
public String call() throws Exception {
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
return "线程结束";
}
}
image.png
这种方式主要是需要处理返回值时使用。
多线程常用的 重点的 核心的 操作方法
多线程主要的操作方法都在Thread类中
- 线程的命名和取得
在Thread类中提供如下的名称操作方法
构造方法，在创建线程对象时设置名称
new Thread(task,"name").start();
setName() 设置线程名字
getName() 取得线程名字
currentThread() 获取当前线程对象
public class Demo1 implements Runnable {
public static void main(String[] args) throws Exception {
Demo1 d = new Demo1();
new Thread(d).start(); // 没有设置名称
new Thread(d).start(); // 没有设置名称
new Thread(d,"哈哈").start(); // 设置了名称
}
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"i="+i); // 获取当前线程对象的名称
}
}
}
image.png
线程未设置名称时会有默认名称
注：避免设置重复线程名称，中途尽量不要修改线程名称
public class Demo1 implements Runnable {
public static void main(String[] args) throws Exception {
Demo1 d = new Demo1();
d.run(); // 直接通过对象调用run()方法，输出结果时main
new Thread(d).start(); // 通过线程调用
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()); // 获取当前线程对象的名称
}
}
image.png
上面这段代码可以发现，直接通过对象调用run方法时，获得的线程对象名称是"main"，由于没有通过Thread去调用，而是直接调用方法，而方法此时获得的线程对象名称则是主方法main()的名称，证明主方法main()就是一个线程。所有线程都是通过主线程创建的并启动的。
注：jvm只是一个进程
线程修眠
线程休眠是让线程暂缓执行一下。到了休眠的设定时间之后再恢复执行。
sleep() 休眠方法，参数类型为long，休眠单位使用的是毫秒
让当前线程进入到休眠状态
sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
在调用sleep()方法的过程中，线程不会释放对象锁。
线程的优先级
在Thread类中提供如下的优先级操作方法
setPriority() 设置优先级
getPriority() 获取优先级
对于优先级的设置可以通过Thread类提供的常量来决定
MIN_PRIORITY=1
NORM_PRIORITY=5
MAX_PRIORITY=10
优先级并不是必然的，只是提高概率。
main()主方法的优先级是NORM_PRIORITY
线程的同步与死锁
每一个线程对象轮番抢占资源的问题
当多个线程同时执行时，可能因为物理，网络等等原因造成数据的不完整性、脏读、幻读等等现象
不同步的线程是不安全的，但是其速度快。
使用同步则是限定线程按照顺序一个一个执行，后一个线程必须得等前一个线程执行完毕释放完资源后才能去执行。
通过加“锁”来实现同步，采用synchronized关键字。
有两种处理模式：同步代码块、同步方法。
- 同步代码块
如果要使用同步代码块必须设置一个要锁定的对象。一般锁定当前对象。
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (this) { // 在同一时间段只允许一个线程访问该代码块，其他线程需要等待。
if (t > 0) {
try {
Thread.sleep(200);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("t还剩"+t);
}
}
t--;
}
}
- 同步方法
同步方法则是将synchronized关键字修饰到方法上，则在同一时间段只允许一个线程访问该方法，其他线程需要等待。
同步使程序变得安全，但是速度成反比的变慢了。
同步还会带来一个问题，那就是“死锁”
同步情况下，b线程等待a线程执行完毕后进行执行，而a线程在执行过程中需要调用b线程，这时候b处于等待状态无法被a线程调用，a线程调用不到b线程程序就会一直卡在那里，而现在是同步，其他所有的线程都等着a，程序运行不下去了，暂时性中断执行了。
开发中例如一些实体类的相互引用容易造成死锁
