javaSE进阶（1） 多线程

单核CPU：在一个时间单元只能执行一个线程
并行与并发：并行是对各CPU执行多个任务；并发是单个CPU执行多个任务

线程的创建和使用

• 多线程的创建

1. 继承于Thread类：
   • 创建一个继承于Thread类的子类
   • 重写Thread类的run() -->将此线程执行的操作声明在run()中
   • 创建Thread类的子类对象
   • 通过此对象调用start()

//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);
            }
        }
    }
}

public class Threadtest {
    //3.创建Thread类的子类对象
    public static void main(String[] args) {
        myThread t1 = new myThread();
        //4.通过此对象调用start()
        t1.start();

		//t1是主线程制造的对象，由t1去执行start（）
		System.out.println("hello");
    }
}

2. 线程的调度
   同优先级先进先出，高优先级优先调度

   1. 线程的优先级等级
      * MAX_PRIORITY:10
      * MIN_PRIORITY:1
      * NORM_PRIORITY:5
   2. 涉及的方法：
      * getPriority()：返回线程优先值
      * setPriority(int newPriority)：改变线程的优先级（setPriority(Thred.MAX_PRIORITY)）
   3. 说明:
      * 线程创建时继承父类的优先级
      * 低优先级只是获得调度的概率降低，并非一定是在高优先级线程之后才被调用

3. 实现Runnable接口

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

//创建一个实现了Runnable接口的类
class MThread implements Runnable{
    // 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class RunnableThread {
    public static void main(String[] args) {
        //创建实现类的对象
        MThread m1 = new MThread();
        //将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread1 = new Thread(m1);
        //通过Thread类的对象调用start()
        //①启动线程②调用当前线程的run-->调用了Runnable类型中的target的run()
        thread1.start();
    }
}

• 线程的安全

4. 在Java中我们通过同步机制来解决线程问题

   1. 方式一：同步代码块

   	synchroized(同步监视器){
   	//需要被同步的代码
   	}
   	/*
   	1.操作共享数据的代码，即为需要被同步的代码
   	2.共享数据：多个线程共同操作的变量。比如多线程卖票中的ticket
   	3.同步监视器：锁（俗称）任何一个类的对象都可以充当同步监视器
   	例如:Object ob = new Object();中的ob可以当做监视器
   	多个线程必须同用一把锁
   	当使用runnable时，锁需要静态，因为有三个对象调用可以用this代替，this为本类的对象
   	*/
   

   2. 方法二：同步方法
      如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
      但是声明同步方法时需要方法内只有共享数据
      
      * 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
      * 非静态的同步方法，同步监视器是：this
      静态的同步方法，同步件事情是：当前类本身（类.class）

   3. 同步的方式，解决了线程的安全问题
      但是操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

5. 死锁问题
   * 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
   * 说明：
   出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续
   我们使用同步时，要避免出现死锁。

public static void main(String[] args) {

    StringBuffer s1 = new StringBuffer();
    StringBuffer s2 = new StringBuffer();

    new Thread(){
        @Override
        public void run() {
            synchronized (s1){

                s1.append("a");
                s2.append("1");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (s2){
                    s1.append("b");
                    s2.append("2");

                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }
    }.start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (s2){

                s1.append("c");
                s2.append("3");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (s1){
                    s1.append("d");
                    s2.append("4");

                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }
    }).start();

}