- 进程
- 进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行、执行完毕、最终消亡的过程。
- 线程
- 多线程
Java中线程实现的方式
> 在 Java 中实现多线程有两种手段，一种是继承 Thread 类，另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用。
- 实现 Runnable 接口
package Thread;
public class MyThread implements Runnable { // 实现Runnable接口，作为线程的实现类
private String name; // 表示线程的名称
MyThread(String name) {
this.name = name; // 通过构造方法配置name属性
}
// TODO 覆写run()方法，作为线程 的操作主体
@Override
public void run() {
for (int i = 0; i < 4; i++) {
System.out.println(name + "运行，i = " + i);
}
}
public static void main(String[] args) {
MyThread mt1 = new MyThread("线程A"); // 实例化对象
MyThread mt2 = new MyThread("线程B"); // 实例化对象
Thread t1 = new Thread(mt1); // 实例化Thread类对象
Thread t2 = new Thread(mt2); // 实例化Thread类对象
t1.start(); // 启动多线程
t2.start(); // 启动多线程
// 线程A运行，i = 0
// 线程A运行，i = 1
// 线程A运行，i = 2
// 线程B运行，i = 0
// 线程B运行，i = 1
// 线程B运行，i = 2
// 线程B运行，i = 3
// 线程A运行，i = 3
}
}
- 继承 Thread 类
package Thread;
public class MyThread extends Thread { // 继承Thread类，作为线程的实现类
private String name; // 表示线程的名称
public MyThread(String name) {
this.name = name; // 通过构造方法配置name属性
}
public void run() { // 覆写run()方法，作为线程 的操作主体
for (int i = 0; i < 4; i++) {
System.out.println(name + "运行，i = " + i);
}
}
public static void main(String[] args) {
MyThread mt1 = new MyThread("线程A "); // 实例化对象
MyThread mt2 = new MyThread("线程B "); // 实例化对象
mt1.start(); // 调用线程主体
mt2.start(); // 调用线程主体
// 线程A 运行，i = 0
// 线程B 运行，i = 0
// 线程A 运行，i = 1
// 线程B 运行，i = 1
// 线程A 运行，i = 2
// 线程B 运行，i = 2
// 线程A 运行，i = 3
// 线程B 运行，i = 3
}
}
- 取得和设置线程的名称
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() {
for (int i = 0; i < 4; i++) {
System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread(); //定义Runnable子类对象
new Thread(myThread).start(); //系统自动设置线程名称
System.out.println("------------");
new Thread(myThread, "线程A").start(); //手工设置线程名称
/*Thread-0运行,第0次！
Thread-0运行,第1次！
Thread-0运行,第2次！
Thread-0运行,第3次！
线程A运行,第0次！
线程A运行,第1次！
线程A运行,第2次！
线程A运行,第3次！*/
}
}
- 运行结果
- 从程序可以看出，现在的两个线程对象是交错运行的，哪个线程对象抢到了 CPU 资源，哪个线程就可以运行，所以程序每次的运行结果肯定是不一样的。
- 在线程启动虽然调用的是 start() 方法，但实际上调用的却是 run() 方法定义的主体。
线程的状态变化
> 要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有5种状态，即创建，就绪，运行，阻塞，终止。下面分别介绍一下这几种状态：
- 在此提出一个问题，Java 程序每次运行至少启动几个线程？
- 回答：至少启动两个线程，每当使用 Java 命令执行一个类时，实际上都会启动一个 JVM，每一个JVM实际上就是在操作系统中启动一个线程。
- Java 本身具备了垃圾的收集机制。
- 所以在 Java 运行时至少会启动两个线程，一个是 main 线程，另外一个是垃圾收集线程
- 创建状态
- 在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时它已经有了相应的内存空间和其他资源，但还处于不可运行状态。
- 新建一个线程对象可采用Thread 类的构造方法来实现，例如 “Thread thread=new Thread()”。
- 就绪状态
- 新建线程对象后，调用该线程的 start() 方法就可以启动线程。
- 当线程启动时，线程进入就绪状态。
- 此时，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。
- 运行状态
- 当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。
- 此时，自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。
- 阻塞状态
- 一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时中止自己的执行，进入阻塞状态。
- 在可执行状态下，如果调用sleep(),suspend(),wait() 等方法，线程都将进入阻塞状态。
- 发生阻塞时线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。
- 死亡状态
- 线程调用 stop() 方法时或 run() 方法执行结束后，即处于死亡状态。
- 处于死亡状态的线程不具有继续运行的能力。
线程的操作方法
> 刚才在分析自定义模式工作原理的时候其实就已经提到了，如果想要更改Glide的默认配
- 线程的强制运行
- 在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() { //覆写run()方法
for (int i = 0; i < 4; i++) {
System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread(); //定义Runnable子类对象
new Thread(myThread).start(); //系统自动设置线程名称
System.out.println("------------");
Thread threadA = new Thread(myThread, "线程A");//手工设置线程名称
threadA.start();
for (int i = 0; i < 10; i++) {
if (i > 5) {
try {
threadA.join(); // 线程强制运行
} catch (InterruptedException e) {
e.printStackTrace(); //打印堆栈跟踪
}
}
System.out.println("Main线程运行 --> " + i);
}
/*Main线程运行 --> 0
Main线程运行 --> 1
Main线程运行 --> 2
Main线程运行 --> 3
Main线程运行 --> 4
Main线程运行 --> 5
Thread-0运行,第0次！
Thread-0运行,第1次！
Thread-0运行,第2次！
Thread-0运行,第3次！
线程A运行,第0次！
线程A运行,第1次！
线程A运行,第2次！
线程A运行,第3次！
Main线程运行 --> 6
Main线程运行 --> 7
Main线程运行 --> 8
Main线程运行 --> 9*/
}
}
- 取得和设置线程的名称
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() {
for (int i = 0; i < 4; i++) {
System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread(); //定义Runnable子类对象
new Thread(myThread).start(); //系统自动设置线程名称
System.out.println("------------");
new Thread(myThread, "线程A").start(); //手工设置线程名称
/*Thread-0运行,第0次！
Thread-0运行,第1次！
Thread-0运行,第2次！
Thread-0运行,第3次！
线程A运行,第0次！
线程A运行,第1次！
线程A运行,第2次！
线程A运行,第3次！*/
}
}
线程的操作方法
> 刚才在分析自定义模式工作原理的时候其实就已经提到了，如果想要更改Glide的默认配
- 线程的强制运行
- 在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() { //覆写run()方法
for (int i = 0; i < 4; i++) {
System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread(); //定义Runnable子类对象
new Thread(myThread).start(); //系统自动设置线程名称
System.out.println("------------");
Thread threadA = new Thread(myThread, "线程A");//手工设置线程名称
threadA.start();
for (int i = 0; i < 10; i++) {
if (i > 5) {
try {
threadA.join(); // 线程强制运行
} catch (InterruptedException e) {
e.printStackTrace(); //打印堆栈跟踪
}
}
System.out.println("Main线程运行 --> " + i);
}
/*Main线程运行 --> 0
Main线程运行 --> 1
Main线程运行 --> 2
Main线程运行 --> 3
Main线程运行 --> 4
Main线程运行 --> 5
Thread-0运行,第0次！
Thread-0运行,第1次！
Thread-0运行,第2次！
Thread-0运行,第3次！
线程A运行,第0次！
线程A运行,第1次！
线程A运行,第2次！
线程A运行,第3次！
Main线程运行 --> 6
Main线程运行 --> 7
Main线程运行 --> 8
Main线程运行 --> 9*/
}
}
- 线程的休眠
- 在程序中允许一个线程进行暂时的休眠，直接使用 Thread.sleep() 即可实现休眠。
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() {
for (int i = 0; i < 4; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
}
}
public static void main(String[] args) {
MyThread mt = new MyThread(); //实例化Runnable子类对象
Thread t = new Thread(mt, "线程"); //实例化Thread对象
t.start(); //启动线程
/*线程运行,第0次！
线程运行,第1次！
线程运行,第2次！
线程运行,第3次！
TODO 每隔0.5秒输出一次
*/
}
}
- 中断线程
- 当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() {
System.out.println("1、进入run()方法");
try {
Thread.sleep(10000); //线程休眠10秒
System.out.println("2、已经完成了休眠");
} catch (InterruptedException e) {
System.out.println("3、休眠被终止02");
return; // 返回调用处
}
System.out.println("4、run()方法正常结束");
}
public static void main(String[] args) {
MyThread mt = new MyThread(); //实例化Runnable子类对象
Thread t = new Thread(mt, "线程"); //实例化Thread对象
t.start(); //启动线程
try {
Thread.sleep(2000); // 线程休眠2秒
} catch (InterruptedException e) {
System.out.println("3、休眠被终止01");
}
t.interrupt(); // 中断线程执行
// 1、进入run()方法
// 3、休眠被终止02
}
}
- 后台线程
- 在 Java 程序中, 只要前台有一个线程在运行, 则整个 Java 进程都不会消失, 所以此时可以设置一个后台线程, 这样即使 Java 线程结束了, 此后台线程依然会继续执行, 要想实现这样的操作, 直接使用 setDaemon() 方法即可。
- 在线程类 MyThread 中，尽管 run() 方法中是死循环的方式，但是程序依然可以执行完，因为方法中死循环的线程操作已经设置成后台运行。
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() {
for (int i = 0; i < 4; i++) {
System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
}
}
public static void main(String[] args) {
MyThread mt = new MyThread(); //实例化Runnable子类对象
Thread t = new Thread(mt, "线程"); //实例化Thread对象
t.setDaemon(true); //设置线程在后台运行, 不会打印日志
t.start(); //启动线程
}
}
- 线程的优先级
- 在 Java 的线程操作中, 所有的线程在运行前都会保持在就绪状态, 那么此时, 哪个线程的优先级高, 哪个线程就有可能会先被执行。
- 从程序的运行结果中可以观察到, 线程将根据其优先级的大小来决定哪个线程会先运行, 但是需要注意并非优先级越高就一定会先执行, 哪个线程先执行将由 CPU 的调度决定。
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() {
for (int i = 0; i < 4; i++) {
System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
}
}
public static void main(String[] args) {
MyThread mt01 = new MyThread(); //实例化Runnable子类对象
MyThread mt02 = new MyThread();
MyThread mt03 = new MyThread();
Thread t01 = new Thread(mt01, "线程A"); //实例化Thread对象
Thread t02 = new Thread(mt02, "线程B"); //实例化Thread对象
Thread t03 = new Thread(mt03, "线程C"); //实例化Thread对象
//设置线程的优先级
t01.setPriority(Thread.MAX_PRIORITY); // 优先级最高
t02.setPriority(Thread.NORM_PRIORITY); // 优先级最中等
t03.setPriority(Thread.MIN_PRIORITY); // 优先级最低
t01.start();
t02.start();
t03.start();
/*线程A运行,第0次！
线程A运行,第1次！
线程A运行,第2次！
线程A运行,第3次！
线程B运行,第0次！
线程B运行,第1次！
线程B运行,第2次！
线程B运行,第3次！
线程C运行,第0次！
线程C运行,第1次！
线程C运行,第2次！
线程C运行,第3次！*/
}
}
- 线程的礼让
- 在线程操作中，也可以使用 yield() 方法将一个线程的操作暂时让给其他线程执行
public class MyThread implements Runnable { //实现Runnable接口
@Override
public void run() {
for (int i = 0; i < 4; i++) {
try {
Thread.sleep(500);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName() + "运行,第" + i + "次！"); //取得当前线程的名称
if (i == 2) {
System.out.print("线程礼让: ");
Thread.currentThread().yield(); //线程礼让
}
}
}
public static void main(String args[]) {
MyThread my = new MyThread(); // 实例化MyThread对象
Thread t1 = new Thread(my, "线程A");
Thread t2 = new Thread(my, "线程B");
t1.start();
t2.start();
/*线程B运行,第0次！
线程A运行,第0次！
线程B运行,第1次！
线程A运行,第1次！
线程A运行,第2次！
线程B运行,第2次！
线程礼让: 线程礼让: 线程A运行,第3次！
线程B运行,第3次！*/
}
}
同步以及死锁
- 一个多线程的程序如果是通过 Runnable 接口实现的，则意味着类中的属性被多个线程共享，那么这样就会造成一种问题，如果这多个线程要操作同一个资源时就有可能出现资源同步问题。
synchronized(同步对象){
需要同步的代码
}
class MyThread implements Runnable{
private int ticket = 5 ; // 假设一共有5张票
public void run(){
for(int i=0;i<100;i++){
synchronized(this){ // 要对当前对象进行同步
if(ticket>0){ // 还有票
try{
Thread.sleep(300) ; // 加入延迟
}catch(InterruptedException e){
e.printStackTrace() ;
}
System.out.println("卖票：ticket = " + ticket-- );
}
}
}
}
};
public class SyncDemo02{
public static void main(String args[]){
MyThread mt = new MyThread() ; // 定义线程对象
Thread t1 = new Thread(mt) ; // 定义Thread对象
Thread t2 = new Thread(mt) ; // 定义Thread对象
Thread t3 = new Thread(mt) ; // 定义Thread对象
t1.start() ;
t2.start() ;
t3.start() ;
/*卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1*/
}
};
- 同步方法
- 除了可以将需要的代码设置成同步代码块外，也可以使用 synchronized 关键字将一个方法声明为同步方法。
- 从程序运行的结果可以发现，此代码完成了与之前同步代码同样的功能。
synchronized 方法返回值 方法名称（参数列表）{}
class MyThread03 implements Runnable {
private int ticket = 5; // 假设一共有5张票
public void run() {
for (int i = 0; i < 100; i++) {
this.sale(); // 调用同步方法
}
}
public synchronized void sale() { // 声明同步方法
if (ticket > 0) { // 还有票
try {
Thread.sleep(300); // 加入延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("卖票：ticket = " + ticket--);
}
}
};
public class SyncDemo03 {
public static void main(String args[]) {
MyThread03 mt = new MyThread03(); // 定义线程对象
Thread t1 = new Thread(mt); // 定义Thread对象
Thread t2 = new Thread(mt); // 定义Thread对象
Thread t3 = new Thread(mt); // 定义Thread对象
t1.start();
t2.start();
t3.start();
/*卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1*/
}
};
- 死锁
- 同步可以保证资源共享操作的正确性，但是过多同步也会产生问题。例如，现在张三想要李四的画，李四想要张三的书，张三对李四说“把你的画给我，我就给你书”，李四也对张三说“把你的书给我，我就给你画”两个人互相等对方先行动，就这么干等没有结果，这实际上就是死锁的概念。
- 所谓死锁，就是两个线程都在等待对方先完成，造成程序的停滞，一般程序的死锁都是在程序运行时出现的。
- 下面以一个简单范例说明这个概念, 以下代码不再执行，程序进入死锁状态。
class Zhangsan { // 定义张三类
public void say() {
System.out.println("张三对李四说：“你给我画，我就把书给你。”");
}
public void get() {
System.out.println("张三得到画了。");
}
};
class Lisi { // 定义李四类
public void say() {
System.out.println("李四对张三说：“你给我书，我就把画给你”");
}
public void get() {
System.out.println("李四得到书了。");
}
};
public class ThreadDeadLock implements Runnable {
private static Zhangsan zs = new Zhangsan(); // 实例化static型对象
private static Lisi ls = new Lisi(); // 实例化static型对象
private boolean flag = false; // 声明标志位，判断那个先说话
public void run() { // 覆写run()方法
if (flag) {
synchronized (zs) { // 同步张三
zs.say();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (ls) {
zs.get();
}
}
} else {
synchronized (ls) {
ls.say();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (zs) {
ls.get();
}
}
}
}
public static void main(String args[]) {
ThreadDeadLock t1 = new ThreadDeadLock(); // 控制张三
ThreadDeadLock t2 = new ThreadDeadLock(); // 控制李四
t1.flag = true;
t2.flag = false;
Thread thA = new Thread(t1);
Thread thB = new Thread(t2);
thA.start();
thB.start();
//张三对李四说：“你给我画，我就把书给你。”
//李四对张三说：“你给我书，我就把画给你”
}
};
线程的启动方式
public class Test {
public static void main(String[] args) {
//线程启动01
Thread magotan = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("MAGOTAN");
}
});
//线程启动02
Thread passat = new Thread(() -> System.out.println("PASSAT"));
//一汽
magotan.run();
//上汽
passat.run();
}
//TODO: MAGOTAN PASSAT
}