【Kay】Java多线程

 * 多线程的创建
  方式一：继承Thread类
 * 1. 创建一个继承于Thread类的子类
 * 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
 * 3. 创建该子类的对象
 * 4. 调用start()
 
* 例子：遍历100以内的所有的偶数

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                try {
                    sleep(1000); // 单位是1000毫秒 = 1s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            if (i % 20 == 0) {
                yield();
            }
        }
    }
}


public class ThreadTest{
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.setName("多线程哦");
        t.setPriority(Thread.MAX_PRIORITY);   //设置分线程的优先级
        t.start();//进入多线程
        //以下是主进程
        Thread.currentThread().setName("主线程哦");
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName());//调取当前线程名字
            }
        }
    }

}

/*
 * Thread中的常用方法：
 * 1. start():启动当前线程；调用当前线程的run()
 * 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
 * 3. currentThread():返回执行当前代码的线程
 * 4. getName():获取当前线程的名字
 * 5. setName():设置当前线程的名字
 * 6. yield():释放当前cpu的执行权
 * 7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
 * 9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前
 *                          线程是阻塞状态。
 * 10. isAlive():判断当前线程是否存活
 *
 *
 * 线程的优先级：
 * 1.MAX_PRIORITY：10
 * MIN _PRIORITY：1
 * NORM_PRIORITY：5  -->默认优先级
 * 2.如何获取和设置当前线程的优先级：
 *   getPriority():获取线程的优先级
 *   setPriority(int p):设置线程的优先级
 *
 *   说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下
 *   被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
 *
*/

/*多线程的创建
方式二：用Runnable接口
①创建一个类，实现Runnable接口
②实现Runnable中的run()方法
③创建实现①中类的对象
④将此对象作为参数传入Thread构造器中，创建Thread类的对象
 */

//创建三个窗口卖票，总票数为100张(用Runnable接口)

class Window implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName() + "卖票：票号为："+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

public class WindowRunnable {
    public static void main(String[] args) {
        Window ww = new Window();
        Thread t11 = new Thread(ww);  //将Runnable对象ww和Thread对象t11相关联
        Thread t22 = new Thread(ww);

        t11.setName("窗口一");
        t22.setName("窗口二");

        t11.start();  //Thread对象t11调用start();
        t22.start();
    }
}

//注意：用Runnable不需要加static，因为制造了一个Window对象ww，三个线程都用的这个对象。

*如何解决多线程存在的安全问题

对多个线程共享数据的语句，Java可以通过同步机制来解决，即让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

1.同步代码块

synchronized(对象){
//需要被同步的代码；
}

2.放在方法声明中同步方法

public synchronized void show (String name){
….
}

*什么是死锁?如何解决？
不同的线程分别占用对方需要的同步资源，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。出现死锁后，不会出现异常和提示，只是所有的线程都处于阻塞状态，无法继续
解决方法：
1、过显式定义同步锁对象来实现同步。Lock接口中的锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程访问共享资源之前应先获得Lock对象
2、尽量减少同步资源的定义，尽量避免嵌套同步