JAVA多线程：

学习笔记
对多线程的理解(小白学习)

学习内容：

多线程
1、了解线程
2、多线程的创建
3、线程优先级
4、生命周期
5、线程的安全

了解线程：

1、程序

程序是为完成特定任务、用某一计算机语言编写的代码的集合。即一段静态代码，静态对象

2、进程

程序的一次执行过程，或是正在运行的一个程序。
一个动态的过程：产生、存在、消亡（生命周期）

3、线程

一个程序内部的一条执行路径。

若是一个进程同一时间并行执行多个线程，就是支持多线程的
线作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器

创建多线程：

多线程的创建：

方式一：继承于Thread类

1、创建一个继承于Thread类的子类
2．重写Thread类的run() -->此线程的操作
3.创建Thread类的子类的对象
4.通过此对象调用start()

//1、创建一个继承于Thread类的子类
class MyThread extends Thread{
    @Override
    //2．重写Thread类的run() -->此线程的操作
    public void run() {
            }
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start()
        t1.start();
        //star会启动当前线程;并且调用当前线程的run();
    }
}

Thread类中常用的方法

     * 1、start()//启动当前线程;调用当前线程的run();
     * 2、run()//插常需要塑写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
     * 3、currentThread()//静金方法，返回执行当前代码的线程
     * 4、getName ()//获取当前线程的名字
     * 5、etName()//设置当菊线程的名字
     * 6、yield()//释放当前cpu的执行权，做出让步
     * 7、jion()//在主方法中调用h1.join(),主方法停止进程直到h1线程结束
     * 8、stop()//已经过时  强制结束线程
     * 9、sleep(long millitime)//让当前线程睡眠指定的毫秒数(停一断  再执行)
     * 10、isAlive()//判断当前线程是否存活

Thread.currentThread().getName()  //在main中可用Thread.currentThread()获得线程，获得后即可调用Thread类下的方法

方式二：实现Runnable接口的方式

相比于直接继承Tread的优点：可以继承其他类

1、创建一个实现了Runnable接口的类
2、实现类去实现Runnable中的抽象方法
3、创建实现类的对象
4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5、通过Thread类的对象调用start()；

//创建一个实现Runnable接口的类
class mThread implements Runnable{
    @Override
    public void run() {
        }
 }
public class ThreadTest2 {
    public static void main(String[] args) {
        //创建类的实例对象
        mThread mt =new mThread();
        //将实例对象作为参数构造Thread的对象
        Thread t1 = new Thread(mt);
        t1.start();
       /*start作用
        1、启动线程
        2、调用当前线程的run()--->调用Runnable类型中的她target的run();
         */
    }
}

也是相当于重写了Thread的run方法

方式三：实现Callable接口的方法

1、创建一个实现了Callable接口的类，重写Callable接的call()方法
2、创建Callable接口的实现类对象
3、通过FutureTask线程结果处理类的有参构造方法来封装Callable接口实现类对象
4、使用参数为FutureTask类的对象Thread有参构造方法创建Thread线程实例
5、调用线程实例的start()方法启动线程

import java.util.concurrent.Callable;
public class MyThread implements Callable<Object> {
	@Override
	public Object call() throws Exception {
		// TODO Auto-generated method stub
		//线程运行的代码块
		int i=0;
		while(i++<5) {
			System.out.println(Thread.currentThread().getName()+"的call()方法正在运行");
		}
		return i;
	}
}


//创建实例对象，并调用线程
import java.util.concurrent.FutureTask;

public class MyThreadDemo {
	public static void main(String[] args) {
		//创建实现Callable接口的实例对象
		MyThread thread = new MyThread();
		//创建以实现Callable实例对象为参数的FutrueTask实例对象
		FutureTask<Object> ft = new FutureTask<Object>(thread);
		//以FutureTask为参数创建Thread的实例对象
		Thread th = new Thread(ft, "线程一");
		//调用Start()方法，运行此线程
		th.start();
	}
}

线程的状态以及周期问题：

1、 NEW(新建状态)

创建线程对象后，即处于新建状态，此时不能运行，但是JVM分配了内存

2、 RUNNABLE(可运行状态)

①就绪状态：线程对象调用start()方法后，等待JVM的调度，此时没运行
②运行状态：线程对象获得JVM的调度，如果存在多个CPU，那么允许多个线程并行运行。

3、 BLOCKED(阻塞状态)

两种情况：
①当线程A运行过程中，试图获取同步锁，却被线程B获取，此时线程A就会被JVM锁在线程池里，线程A将进入阻塞状态
②当线程运行过程中，发出I/O请求时，此时该线程也会进去阻塞状态

4、WAITING(等待状态)

当处于运行状态的线程调用了wait()，join()等方法时，将线程状态变为等待状态。除于等待状态的线程不能立即争夺CPU的使用权，必须等其他线程执行操作之后才可以。
注： ①调用wait()方法而处于等待状态的线程，必须等待其他线程调用notify()或者notifyall()方法唤醒当前等待中的线程；
②调用join()方法的而处于等待状态中的线程，必须等待其他线程加入的线程终止

5、TIMED_WAITING(定时等待状态)

将运行的线程转化为定时等待状态中的线程与转换为等待状态中的线程操作类似，只是调用了有时间限制的方法，如：sleep()，wait()，join()等方法。
注：取消此状态也需要和取消等待状态有类似的操作

6、TERMINATED(终止状态)

线程的run()方法、call()方法正常执行完毕或者线程抛出一个未捕获的异常、错误，线程就进入终止状态，不在具有运行的资格

在这里插入图片描述

线程的优先级：

优先级常量：

static int MAX_PRIORITY   表示线程的最高优先级，相当于10
static int MIN_PRIORITY   表示线程的最高优先级，相当于1
static int NORM_PRIORITY   表示线程的最高优先级，相当于5

使用方法：

public class MyThreadDemo {
	public static void main(String[] args) {
		Thread th1 = new Thread(() -> {
			for (int i = 0; i < 10; i++) {
				System.out.println(Thread.currentThread().getName() + "正在输出i：" + i);
			}
		}, "线程一");

		Thread th2 = new Thread(() -> {
			for (int i = 0; i < 10; i++) {
				System.out.println(Thread.currentThread().getName() + "正在输出i：" + i);
			}
		}, "线程二");

		// 设置优先级
		th1.setPriority(Thread.MIN_PRIORITY);
		th2.setPriority(Thread.MAX_PRIORITY);
		// 运行线程
		th1.start();
		th2.start();
	}
}
运行结果：
线程一正在输出i：0
线程一正在输出i：1
线程一正在输出i：2
线程一正在输出i：3
线程一正在输出i：4
线程一正在输出i：5
线程一正在输出i：6
线程一正在输出i：7
线程一正在输出i：8
线程一正在输出i：9
线程二正在输出i：0
线程二正在输出i：1
线程二正在输出i：2
线程二正在输出i：3
线程二正在输出i：4
线程二正在输出i：5
线程二正在输出i：6
线程二正在输出i：7
线程二正在输出i：8
线程二正在输出i：9