多线程、同步

1.多线程

1.1多线层的优缺点

优点：

    1.提升资源利用率

    2.提高用户体验

缺点：

    1.降低了其他线程的执行概率

    2.用户会感受到软件的卡顿问题

    3.增加的系统、资源压力

    4.多线程请款下的共享资源问题，线程冲突、线程安全问题

1.2创建自定义线程类的两种方式

class Thread 类

 

    java中的一个线程类

    Thread类是Runnable接口的实现类，同时提供了很多线程的操作使用的方法

interface Runable接口

     这里规定了那个将要被运行

     这里只有一个方法 run方法

方式一：

     自定义线程类，继承Thread类，重写run方法

    创建自定义线程对象，直接调用start方法，开启线程

方式二：

     自定义线程类，遵从Runable接口

     使用自定义接口Runable实现类对象，作为Thread构造方法参数

      借助于Thread类对象和start方法，开启线程

推荐使用方法二，遵从runable接口来完成自定义线程、不影响正常的继承逻辑，并且可以使用匿名内部类来完成线程代码块 的编写

package com.company;

/**
 * 自定义线程类MyThread继承Thread类
 */

class MyThread extends Thread{

    @Override
    public void run(){
        for (int i =0;i<100;i++){
            System.out.println("继承Thread类自定义线程类");
        }

    }

}

/**
 * 自定义线程类MyThread2遵从Runable接口
 */

class MyThread2 implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println("遵从Runable接口实现自定义线程类");
        }
    }
}
public class Main {

    public static void main(String[] args) {

        for (int i=0;i<100;i++){
            System.out.println("main线程");


        }

        //创建一个继承Thread类自定义线程类对象
        MyThread myThread =new MyThread();

        myThread.run();
      //  myThread.run();

        myThread.start();

        //创建一个Thread类对象，使用遵从Runable接口的实现类作为构造方法的参数
        Thread thread = new Thread(new MyThread2());
        thread.start();
        // write your code here
    }
}

自定义线程执行流程简述：

 

 

 

1.4 Thread类的一些方法

构造方法：Constructor

      Thread（）；

             分配一个新的线程对象、无目标、无名字

      Thread(Runable target):

              创建一个新的线程对象，并且在创建线程对象的过程中，使用Runable接口的实现类对象作为执行的线程代码块目标

       Thread（String name)

                 创建一个新的线程，无指定目标，但是指定当前线程的名字是什么

       Thread(Runable target , String name)

                 创建一个现成的线程对象，使用Runable接口实现类对象，作为执行目标，并且指定name作为线程名

成员方法：

          void setName(String name)；

          String getName();

              以上两个是name属性setter和getter方法

          void setPriority （int priority）；

               设置现成的优先级、非一定要执行要求、只是增加执行的概率

           int setPriority();

                  获取线程优先级

            void  start();

                    启动线程对象

             public static void sleep(int ms);
                    当前方法是静态方法，通过Thread类调用，要求是当前所在线程代码块对应的线程，
        进行休眠操作，休眠指定的毫秒数
                 public static Thread currentThread();
                     当前方法是静态方法，通过Thread类调用，获取当前所处代码块对应的线程对象。

package com.company;

public class Demo1 {

    public static void main(String[] args) {
        Thread thread1 =new Thread();
        Thread thread2 =new Thread("线程");
        //给予Thread类构造方法Runable接口实现类对象
        Thread thread3 =new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类对象作为线程执行目标");
            }
        });
         Thread thread4 = new Thread(new Runnable() {
             @Override
             public void run() {
                 System.out.println("匿名捏不累对象作为线程");
             }
         },"匿名内部类对象");


        System.out.println(thread1);
        System.out.println(thread2);
        System.out.println(thread3);
        System.out.println(thread4);
    }
}

  

package com.Demo1;
class MyThread3 implements Runnable{

    @Override
    public void run() {
        for (int i =0;i<100;i++){
            try {
                /**
                 * 为什么这里只能抛出异常而不能捕获异常
                 * run方法时实现/重写Runable接口/Thread类内方法
                 * 重写方法只有一个要求，方法的声明必须和接口或者父类一致
                 * Runable接口和Thread类内run方法都没有进行任何抛出操作
                 * 子类中重写run方法也不能抛出、保障声明一致
                 * @Overrid注解，严格的格式检查
                 */
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("自定义线程");
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程目标代码");

            }
        }, "线程目标");


        System.out.println(thread.getName());

        thread.setName("匿名线程");
        System.out.println(thread.getName());
        Thread.sleep(1000);
        System.out.println(thread.getPriority());

        /**
         * Thread.MIN_PRIORITY 最小 1
         * Thread.MAX_PRIORITY 最大 10
         * Thread.NORM_PRIORITY  正常 5
         *
         *
         */
        thread.setPriority(Thread.NORM_PRIORITY);
        System.out.println(thread.getPriority());
    }
}