Java---多线程（上）

多线程（上）

1.多线程的引入

（1）线程是程序执行的一条路径，一个进程可以包含多条线程
（2）多线程并发执行可以提高程序效率，同时可以完成多项工作
举例：QQ多人视频；迅雷开启多个线程同时下载；服务器处理多个客户信息
原理：当多个程序同时进行时，CPU在每个程序之间快速转换，准确来说CPU在某个时间在执行一个程序。

2.多线程并行与并发的区别

（1）并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
（2）并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。

3.多线程实现的方式

方式一

（1）声明Thread的子类，并重写run方法，创建Thread的子类对象，调用start方法（而不是run方法）

public static void main(String[] args) {
  Demo2 d = new Demo2();
  d.start();
   
  for (int i = 0; i < 10000; i++) {
   System.out.println("aaa");
  }
 }
}
class Demo2 extends Thread{
 @Override
 public void run() {
  for (int i = 0; i < 10000; i++) {// 输出结果为aaa、bbbbb交叉出现
   System.out.println("bbbbb");
  }
 }
}

在以上代码中，当for循环次数较少时，则会先输出主线程中的内容，这是因为CPU的效率很高，在开启另一个线程的这段时间中主线程中的方法已经执行完毕。
方式二
（2）声明实现runnable接口的类，重写run方法，创建该类对象，传递给Thread，调用start方法

使用匿名内部类实现两种方式
可以不用继承和实现，只需重写run方法，可以使代码更简洁

new Thread() {
   public void run() {
    for (int i = 0; i < 10000; i++) {
     System.out.println("aaa");
    }
   }
  }.start();
  
   new Thread(new Runnable() {

   @Override
   public void run() {
    for (int i = 0; i < 10000; i++) {
     System.out.println("bbb");
    }
   }
  }).start(); 

附：多线程实现的第三种方式Callable

public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService e = Executors.newFixedThreadPool(2);
        Solution solution = new Solution(5);
        Future f1 = e.submit(solution);
        Future f2 = e.submit(new Solution(10));
        System.out.println(f1.get());
        System.out.println(f2.get());
        e.shutdown();
    }
}
class Solution implements Callable {
    private  int num;
    public Solution(int num) {
        this.num = num;
    }
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        return num + 2;
    }
}

4.多线程实现的两种方式的区别

• 查看源码的区别:
  （1）继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
  （2）实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
• 继承Thread
  （1）好处是:可以直接使用Thread类中的方法,代码简单
  （2）弊端是:如果已经有了父类,就不能用这种方法实现
• Runnable接口
  （1）好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
  （2） 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

5.线程的部分功能

• 线程名字的设置
  （1）构造方法中设置名字
  （2）使用setName()设置名字

public static void main(String[] args) {
    new Thread("张三") {
        @Override
        public void run() {
            System.out.println(this.getName() + "····aaa");
        }
    }.start();
    new Thread() {
        @Override
        public void run() {
            this.setName("王五");
            System.out.println(this.getName() + "····ccc");
        }
    }.start();
    Thread  t1 = new Thread() {
        @Override
        public void run() {
            System.out.println(this.getName() + "····bb");
        }
    };
    t1.setName("李四");
    t1.start();
}

运行结果：（多线程的运行时随机的）

• 获取当前线程对象（多用于Runnable方法）

Thread.currentThread()；

public static void main(String[] args) {
    new Thread(new Runnable() {
        @Override
        public void run() {
           System.out.println(Thread.currentThread().getName() + "··aa");
        }
    }).start();
    Thread.currentThread().setName("nini");//改变主线程名字
    System.out.println(Thread.currentThread().getName());
}

6.线程的生命周期

6.线程的管理

（1）休眠线程
Thread.sleep(毫秒值/纳秒值【windows系统不太支持纳秒值】)

• 如果重写run方法不能抛异常，只能抓异常（因为在父类Thread中的run方法没有抛出异常，则在子类中的异常只能由子类自己解决）
  异常处理的相关注意事项

public static void main(String[] args) throws InterruptedException {
    for (int i = 10; i >= 0;i--) {
        System.out.println("倒计时 : " + i );
        Thread.sleep(1000);
    }
}//每隔1s输出一次

（2）守护线程
setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
非守护线程通知运行，其他线程也随之停止；

public static void main(String[] args)  {
    Thread t1 = new Thread() {
        public void run() {
            for(int i = 0; i < 50; i++) {
                System.out.println(getName() + "...aaaaaa");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    Thread t2 = new Thread() {
        public void run() {
            for(int i = 0; i < 2; i++) {
                System.out.println(getName() + "...bb");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    t1.setDaemon(true);                   //将t1设置为守护线程
    t1.start();
    t2.start();

当非守护线程执行完毕时，守护线程也随之停止，但不会立即停止，会有一段时间的缓冲（可能在此时守护线程也会执行）
（3）加入线程
join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
join(int), 可以等待指定的毫秒之后继续交替执行

public static void main(String[] args)  {
    final Thread t1 = new Thread() {
        public void run() {
            for(int i = 0; i < 50; i++) {
                System.out.println(getName() + "...aaaaaa");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    Thread t2 = new Thread() {
        public void run() {
            for(int i = 0; i < 10; i++) {
                if (i == 2) {
                    try {
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(getName() + "...bb");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    t1.start();
    t2.start();
}

（4）礼让线程
yield让出CPU
CPU在执行时在不停的切换，使用Thread.yield()让出CPU让其他线程去执行，但一般效果不明显，和sleep相似，但是sleep()是让线程进入堵塞状态，而yield是使线程进入就绪状态，yield()方法只是让当前线程暂停一下，重新进入就绪的线程池中，让系统的线程调度器重新调度器重新调度一次，完全可能出现这样的情况：当某个线程调用yield()方法之后，线程调度器又将其调度出来重新进入到运行状态执行。

7.设置线程优先级

setPriority()设置线程的优先级
setPriority方法的参数是一个整数，范围是1~10之间，也可以使用Thread类提供的三个静态常量：
MAX_PRIORITY =10
MIN_PRIORITY =1
NORM_PRIORITY =5
每个线程执行时都有一个优先级属性，CPU在执行时会更多的侧重于优先级大的线程，但优先级小的线程并不是完全不会优先执行

public static void main(String[] args)  {
    Thread t1 = new Thread() {
        public void run() {
            for(int i = 0; i < 1000; i++) {
                System.out.println(getName() + "...aaaaaa");
            }
        }
    };
    Thread t2 = new Thread() {
        public void run() {
            for(int i = 0; i < 1000; i++) {
                System.out.println(getName() + "...bb");
            }
        }
    };
    t1.setPriority(Thread.MAX_PRIORITY);
    t2.setPriority(Thread.MIN_PRIORITY);
    t1.start();
    t2.start();
}