Java 多线程基础

、@TOC

---

前言

程序：是为完成特定任务、用某种语言编写的一组指令的集合。
进程：程序的一次执行过程，或者是正在运行中的程序。是一个动态的过程：有它自 身的产生、存在、消亡的过程
线程：进程可以进一步细分为线程，是一个程序内部的一条执行路径。
并行：多个cpu同时执行多个任务
并发：一个CPU同时执行多个任务

一、线程的创建和使用（熟练）

1.继承Thread类

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run()
3. 创建Thread类的子类对象
4. 通过此对象调用start()方法

/**
 * 多线程创建，方式一：继承与Thread类
 * 1.创建一个继承于Thread类的子类
 * 2.重写thread类的run()
 * 3.创建Thread类的子类对象
 * 4.通过此对象调用start()
 *
 *
 * 例子：遍历100以内的所有的偶数
 */

/**
   * 1.创建一个继承于Thread类的子类
     */
class MyThread extends Thread{
        /**
         * 2.重写Thread的run()
         */
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i + " " + Thread.currentThread().getName());
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        myThread1.start();
        MyThread myThread2 = new MyThread();
        myThread2.start();
    }
}

start()方法的作用：

1. 启动当前线程
2. 调用当前线程的run()

Thread常用方法

1. start():启动当前线程，调用当前线程的run()
2. run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3. currentThread():静态方法，返回当前代码的线程
4. getName():获取当前线程的名字
5. setName():设置当前线程的名字
6. yield():释放当前CPU的执行权
7. join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞
8. stop():已过时，当执行此方法时，强制结束当前线程
9. sleep(long millitime):让当前线程睡眠指定的millitime时间，在指定的millitime毫秒时间内，当前线程阻塞
   10.isAlive()：判断当前线程是否存活

线程优先级

1. MAX_PRIORITY:10
   MIN_PRIORITY:1
   NORM_PRIORITY:5
2. 获取和设置优先级
   getPriority():获取当前线程的优先级
   setPriority():设置线程的优先级
   说明：高优先级的线程要抢占低优先级线程的CPU的执行权。但是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有高优先级线程执行完以后，低优先级的线程才被执行。

2.实现Runnable接口（熟练使用）

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

class MThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class RunnableTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.start();
    }
}

使用匿名类实现

class Thread1{
    public void test(){
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class RunnableTest2 {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        new Thread(new Runnable() {
            @Override
            public void run() {
                thread1.test();
            }
        },"AA").start();
    }
}

使用实现Runnable接口创建多线程实现三个窗口卖100张票

**
 * 使用实现Runnable接口创建多线成
 * 创建多线程实现，三个窗口卖100张票
 */
//1.创建资源类,定义属性和方法
class showTicket{
    int number = 100;
    private final ReentrantLock reentrantLock = new ReentrantLock();
    //买票方法
    public void saleTicket(){
        reentrantLock.lock();
        try {
            //判断是否有票
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "：卖出：" + number-- + "剩余：" +number);
            }
        } finally {
        reentrantLock.unlock();
        }
    }
}
public class Windows {
    public static void main(String[] args) {
        showTicket showTicket = new showTicket();
        //创建多线程，调用卖票方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    showTicket.saleTicket();
                }
            }
        },"AA").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    showTicket.saleTicket();
                }
            }
        },"BB").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    showTicket.saleTicket();
                }
            }
        },"CC").start();
    }
}

二、线程的生命周期

1.五种状态及关系

三、同步解决线程安全问题

1.同步代码块

synchronized(同步监视器){
//需要被同步的代码
}
说明：

1. 操作共享数据的代码，即为需要被同步的代码
2. 共享数据：多个线程共同操作的变量。
3. 同步监视器：俗称锁，任何一个类的对象，都可以充当锁。

以卖票为例

class Ticket1{
    private int number = 100;
    private Object object = new Object();
    public void saleTicket(){
        synchronized(object){
            if(number > 0 ){
                System.out.println(Thread.currentThread().getName() + ":卖出：" + number-- + "剩余：" + number);
            }
        }
    }
}
public class SynTest {
    public static void main(String[] args) {
        Ticket1 ticket1 = new Ticket1();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    ticket1.saleTicket();
                }
            }
        },"AA").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    ticket1.saleTicket();
                }
            }
        },"BB").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    ticket1.saleTicket();
                }
            }
        },"CC").start();
    }
}

2.同步方法

说明
如果操作的共享数据的代码完整的声明在一个方法中，我们可以将此方法声明为同步的

1. 同步方法仍然涉及到同步监视器，只是不需要显式的声明
2. 非静态的同步方法，同步监视器是this
   静态的同步方法，同步监视器是当前类本身

class Ticket{
    private int number = 100;
    public  synchronized void showTicket1(){
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + ":卖出：" + number-- + "剩余:" + number);
        }
    }
}
public class SynchronizedTest {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 100; i++) {
                    ticket.showTicket1();
                }
            }
        },"AA").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 100; i++) {
                    ticket.showTicket1();
                }
            }
        },"BB").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 100; i++) {
                    ticket.showTicket1();
                }
            }
        },"CC").start();
    }
}