Java面向对象【线程】

进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程；

线程是由进程创建的，是进程的一个实体，一个进程可以拥有多个线程

• 单线程
• 多线程
• 并发
  • 同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，单核cpu实现的多任务就是并发
• 并行
  • 同一个时刻，多个任务同时执行。多核CPU可以实现并行

线程的使用

• 当一个类继承了Thread 类，该类就可以当做线程使用

• 我们会重写run方法，写上自己的业务代码

• run Thread 类 实现了 Runnable 接口 的run 方法

• java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承
  Thread类方法来创建线程显然不可能了。

• java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

代码① 继承Thread

package com.xiaolu.threaduse;

/**
 * @author 林小鹿
 * @version 1.0
 */
public class Thread01 {

    public static void main(String[] args) {
        Cat cat = new Cat();

        /*
            (1)
            public synchronized void start(){
                start0();
            }
            (2)
            //start0()是本地方法，是JVM调用，底层是c/c++实现
            //真正实现多线程的效果，是start0(),而不是 run
            private native void start0();
         */

        cat.start();  // 启动线程 -> 最终会执行cat的run方法

    }

}
// - 当一个类继承了Thread 类，该类就可以当做线程使用
//- 我们会重写run方法，写上自己的业务代码
//- run Thread 类 实现了 Runnable 接口 的run 方法
class Cat extends Thread {
    int times = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("小麋鹿" + (++times) + "线程名=" + Thread.currentThread().getName());
            // 让线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 50) {
                break;
            }
        }
    }
}

代码② 实现Runnable

package com.xiaolu.threaduse;

/**
 * @author 林小鹿
 * @version 1.0
 * main线程中启动两个子线程
 */
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();

    }
}

class T1 implements Runnable {

    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("T1 hello" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }

}

class T2 implements Runnable {

    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("T2 hello" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        if (count == 5)
            break;
        }

    }

}

线程常用方法

• setName： /设置线程名称，使之与参数name相同
• getName： /返回该线程的名称
• start： /使该线程开始执行；Java虚拟机底层调用该线程的start0方法
• run： /调用线程对象run方法：
• setPriority： /更改线程的优先级
• getPriority： /获取线程的优先级
• sleep： /在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
• interrupt： /中断线程（如果是在休眠，则中断休眠）
• yield：线程的礼让。让出cpu,让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
• join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

用户线程和守护线程

• 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
• 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
• 常见的守护线程：垃圾回收机制
  • 可以讲子线程设置成守护线程，这样当所有的用户线程结束时，该子线程也会结束
  • 子线程类名.setDaemon(true);
  • 应该设置于线程启动之前

代码

package com.xiaolu.threaduse;

/**
 * @author 林小鹿
 * @version 1.0
 * 守护线程
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        // 可以讲子线程设置成守护线程，这样当所有的用户线程结束时，该子线程也会结束
        myDaemonThread.setDaemon(true);  // 设置守护线程
        myDaemonThread.start();

        for (int i = 1; i <= 10; i++) {// main 线程
            System.out.println("学习中...");
            Thread.sleep(1000);

        }

    }
}

class MyDaemonThread extends Thread {
    @Override
    public void run() {
        for (;;) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("你好");
        }

    }
}

线程的六大状态

线程状态。线程可以处于以下状态之一：

• NEW
  尚未启动的线程处于此状态。
• RUNNABLE
  在Java虚拟机中执行的线程处于此状态。
  • RUNNABLE中又可以再细分成Ready和Running
• BLOCKED
  被阻塞等待监视器锁定的线程处于此状态。
• WAITING
  正在等待另一个线程执行特定动作的线程处于此状态。
• TIMED WA工TING
  正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
• TERMINATED
  已退出的线程处于此状态。

线程同步机制 Synchronized

在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技
术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。

使用

• 同步代码块

  • synchronized(对象){ // 得到对象的锁，才能操作同步代码
    	// 需要被同步代码；
    }
    

  • 非静态方法时，括号里的对象可以放 this；静态时放 类名.class

• synchronized还可以放在方法声明中，表示整个方法-为同步方法

  • public synchronized void m(String name){
    	// 需要被同步的代码
    }
    

互斥锁

1. 在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
3. 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
4. 同步的局限性：导致程序的执行效率要降低
5. 同步方法（非静态的）的锁可以是this,也可以是其他对象（要求是同一个对象）
6. 同步方法（静态的）的锁为当前类本身。

细节

• 同步方法如果没有使用static修饰：默认锁对象为this
• 如果方法使用static修饰，默认锁对象：当前类.class
• 需要先分析上锁的代码
  选择同步代码块或同步方法
  要求多个线程的锁对象为同一个即可！

死锁

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生，

释放锁

1. 当前线程的同步方法、同步代码块执行结束
   案例：上厕所，完事出来
2. 当前线程在同步代码块、同步方法中遇到break、return。
   案例：没有正常的完事，经理叫他修改bug,不得已出来
3. 当前线程在同步代码块、同步方法中出现了未处理的error或Exception,导致异常结束
   案例：没有正常的完事，发现忘带纸，不得已出来
4. 当前线程在同步代码块、同步方法中执行了线程对象的wat()方法，当前线程暂停，并释放锁。
   案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

不会释放锁的情况

1. 线程执行同步代码块或同步方法时，程序调用Thread.seep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
   案例：上厕所，太困了，在坑位上眯了一会
2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。
   提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

案例1

package com.xiaolu.threaduse;

import java.util.Scanner;

/**
 * @author 林小鹿
 * @version 1.0
 * B线程以通知的方式结束A线程
 * 当按下Q时，A线程退出
 */
public class homework01 {

    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        Thread t_a = new Thread(a);
        Thread t_b = new Thread(b);
        t_a.start();
        t_b.start();
    }
}

class A implements Runnable {

    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
            // 随机打印0~100的数字
            System.out.println((int) (Math.random() * 100 + 1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

class B implements Runnable {
    private A a;
    private Scanner scanner = new Scanner(System.in);
    public B(A a) {
        this.a = a;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("请输入你指令(Q)表示退出：");
            char key = scanner.next().toUpperCase().charAt(0);
            if (key == 'Q') {
                // 以通知的方式结束A线程
                a.setLoop(false);
                System.out.println("b线程退出");
                break;
            }
        }
    }
}

案例2

package com.xiaolu.threaduse;

/**
 * @author 林小鹿
 * @version 1.0
 * 抢票
 */
public class homework02 {

    public static void main(String[] args) {
        T t = new T();
        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(t);
        thread1.setName("t1");
        thread2.setName("t2");
        thread1.start();
        thread2.start();

    }
}

class T implements Runnable{

    private int money = 10003;
    @Override
    public void run() {

        while (true) {
            synchronized (this) {
                // synchronized 实现了线程同步
                // 多线程会去争夺this对象锁
                // 执行完毕后会释放this对象锁(非公平锁)
                if (money < 1000) {
                    System.out.println("余额不足，建议充值V16");
                    break;
                }
                money -= 1000;
                System.out.println(Thread.currentThread().getName() + " ,剩余金额：" + money);
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }
}