菜鸡学习day17_多线程

菜鸡学习day17

package day17;

import java.util.Objects;

/*
void start（）开辟新的栈空间，多线程
Thread类常用方法
1.public String getName() 获取当前线程名称
2.public void start（）开始执行线程，调用run方法
3.public static Thread currentThread（）返回对当前正在执行的线程对象的引用
4.public static void sleep（long millis）使程序暂停一段时间后继续执行
设置线程名称（了）

创建多线程的第二种方法
使用Runnable接口
步骤：1.创建Runnable接口的实现类
     2.在实现类中重写run方法
     3.创建Runnable接口的实现类对象
     4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
     5.调用start开启新线程
注（优点）：1.避免了单继承的局限性
           2.增强了程序的拓展性，把设置线程任务和开启新线程进行了分离

匿名内部类创建多线程，可以简化代码
new Thread(){
重写run
}.start();
Runnabale r = new Runnable(){
重写run
}；
new Thread（r）.start（）；

线程安全问题
多线程访问共享数据

解决方法1
同步代码块
synchronized(锁对象){
可能出现线程安全问题的代码块
}
注：1.锁对象可以是任意对象
    2.要保证多个线程使用的锁对象是同一个，放在Runnable接口的实现类中。
    3.锁对象作用：把代码块锁住，同一时刻只让一个线程执行
原理：使用了一个锁对象/同步锁/对象监视器，同一时刻只让一个线程执行，其他其他线程进入阻塞状态，等待锁对象归还代码块
      当线程0执行完毕，锁对象才释放锁，继续。。。
程序频繁判断/释放锁，效率降低

解决方法2
同步方法
也会把代码锁住，同一时刻只让一个线程执行，随对象是Runnable的实现类对象this
步骤：1.将可能出现线程安全问题的代码块放到一个方法中
     2.在方法上添加synchronized修饰符
修饰符 sunchronized 反水值类型 方法名（参数列表）{
可能出现线程安全问题的代码块
}

解决方法3
静态方法（了）

解决方法4
Lock锁
Lock接口
方法：1.void lock（）获取锁
      2.void unlock（）释放锁
步骤：1.在成员位置创建ReentrantLock对象
      2.在可能出现线程安全问题的代码块之前获取锁
      3.在之后释放锁

线程状态
6种，定义

等待唤醒案例
创建一个顾客线程，告知要求，调用wait方法，放弃cpu执行，无限等待
创建一个老板线程，调用notify方法，唤醒顾客线程1
注：使用同步代码块，保证同一时刻只有单线程执行
    同一个锁对象
    只有锁对象才能调用这两个方法

void wait（long m）相当于sleep
void notify（）随机唤醒单个线程
void notifyAll（）唤醒所有线程
 */
public class D1701 {
    public static void main(String[] args) {
        //MyThread myThread = new MyThread();
        //myThread.start();//线程0
        //new MyThread().start();//线程1
        //System.out.println(Thread.currentThread().getName());//获取主线程名称main
       // sleep();
        //duoxiancheng01();//创建多线程的第二种方法
        //duoxiancheng02();//匿名内部类创建多线程
        //ticket01();
        anli01();
        
    }

    private static void sleep(){
        for (int i = 0; i < 60; i++) {
            try {
                Thread.sleep(1000);//暂停1s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }

    private static void duoxiancheng01(){
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "," + i);
        }
    }

    private static void duoxiancheng02(){//匿名内部类创建多线程
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 6; i++) {
                    System.out.println(Thread.currentThread().getName() + "," + i);
                }
            }
        }.start();

        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 8; i++) {
                    System.out.println(Thread.currentThread().getName() + "," + i);
                }
            }
        };
        new Thread(runnable).start();


    }
    private static void ticket01(){
        Runnable01 runnable = new Runnable01();
        Thread t0 = new Thread(runnable);
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);

        t0.start();
        t1.start();
        t2.start();
    }

    private static void anli01(){
        Object object = new Object();

        new Thread(){

            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("我需要xxx。");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("顾客得到了xxx。");
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                synchronized (object){
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("xxx做好了。");
                    object.notify();
                }
            }
        }.start();
    }
}

package day17;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "," + i);
        }
    }
}

package day17;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Runnable01 implements Runnable {
    private int num = 100;

    Object object = new Object();

    Lock lo = new ReentrantLock();

    @Override
    public void run() {
        while (num > 0) {
           /* synchronized (object){
                if(num > 0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + num + "张票。");
                    num--;
                }
            }
            */

            //tongbumethod01();

            lo.lock();//获取锁
            if (num > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖第" + num + "张票。");
                num--;
            }
            lo.unlock();//释放锁

        }
    }

    private synchronized void tongbumethod01() {//同步方法
        if (num > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖第" + num + "张票。");
            num--;
        }
    }
}

package day17;

public class MyThread extends Thread{
    @Override
    public void run() {
        String name = getName();
        System.out.println(name);//Thread-0
        Thread thread = Thread.currentThread();
        System.out.println(thread);//Thread[Thread-0,5,main]
    }
}