java-----多线程

多线程基本概念

1.什么是多线程？

        有了多线程，我们就可以让程序同时做多件事情
2.多线程的作用？

        提高服从，让cpu在多个程序之间切换
3.多线程的应用场景？

        只要你想让多个事情同时运行就需要多线程
        比如：软件中的耗时利用、所有聊天软件、所有的服务器

并发和并行

1.并发：在同一时刻，有多个指令在单个CPU上瓜代执行
2.并行：在同一时刻，有多个指令在多个CPU上同时执行

多线程三种实现方式

 1.继承Thread类的方式实现

        将一个类声明为Thread的子类。 这个子类应该重写Thread类的方法run。
代码块演示:
           

1. public class MyThread extends Thread{
2.     //子类调用父类的getName方法
3.     @Override
4.     public void run() {//t1 t2都会执行当前
5.         //线程要执行的
6.         for (int i = 0; i < 20; i++) {
7.             Thread thread = Thread.currentThread();
8.             System.out.println(getName()+"helloworld");
9.         }
10.     }
11. }

复制代码

测试类main方法：

1. public class demo1{
2.     public static void main(String[] args) {
3.         //1.自己定义一个类继承Thread
4.         //2.重写run方法
5.         //3.创建子类对象，并启动线程
7.         MyThread t1=new MyThread();
8.         MyThread t2=new MyThread();
10.         t1.setName("线程1");
11.         t2.setName("线程2");
12.         //启动线程
13.         t1.start();
14.         t2.start();
16.     }
17. }
19. 运行结果:仅仅是一部分运行结果，可以看出线程1和2是交替执行的

复制代码

   2.实现Runnable接口的方式举行实现

          创建一个线程是声明实现类Runnable接口。 谁人类然后实现了run方法。 然后可以分配类的实例，在创建Thread时作为参数通报，并启动。
代码演示:
  

1. public class MyRun implements Runnable{
2.     //自强
3.     @Override
4.     public void run() {
5.         for (int i = 0; i < 100; i++) {
6.             Thread thread = Thread.currentThread();//获取当前线程
7.             System.out.println(thread.getName()+"nihao");
8.         }
9.     }
10. }

复制代码

1. public class demo2 {
2.     public static void main(String[] args) {
3.         //1.自己定义一个类实现Runnable接口
4.         //2.重写里面的run方法
5.         //3.创建自己类的对象
6.         //4.创建一个Thread对象，并开启线程
7.         MyRun mr=new MyRun();
8.         Thread t1=new Thread(mr);
9.         Thread t2=new Thread(mr);
10.         t1.setName("线程1");
11.         t1.start();
13.         t2.setName("线程2");
14.         t2.start();
15.     }
16. }

复制代码

 3.使用Callable接口和Future接口方式实现

            可以获得多线程执行的返回结果
  

1. import java.util.concurrent.Callable;
3. public class MyCallable implements Callable<Integer>{
4.     @Override
5.     public Integer call() throws Exception {
6.         int sum=0;
7.         for (int i = 0; i <=100; i++) {
8.             sum+=i;
9.         }
10.         return sum;
11.     }
12. }

复制代码

1. public class demo3 {
2.     public static void main(String[] args) throws ExecutionException, InterruptedException {
3.         //可以获取多线程运行的返回结果
4.         //1.创建MyCallable对象 表示多线程要执行人物
5.         MyCallable mc=new MyCallable();
6.         //创建FutureTask 管理结果
7.         FutureTask<Integer> ft=new FutureTask<>(mc);
8.         Thread t1=new Thread(ft);
9.         t1.start();
10.         Integer result=ft.get();
11.         System.out.println(result);
12.     }
13. }

复制代码

运行结果：
  5050
   多线程中常见成员方法

部分代码演示: 
    线程优先级:
          抢占式调理:随机性、优先级越大，线程抢占概率越大
          

1. public class demo11 {
2.     public static void main(String[] args) {
3.         MyThread4 t1=new MyThread4("坦克");
4.         MyThread4 t2=new MyThread4("飞机");
5.         System.out.println(t1.getPriority());
6.         System.out.println(t2.getPriority());
7.         t1.setPriority(1);
8.         t2.setPriority(10);//最大优先级为10
9.         t1.start();
10.         t2.start();
11.     }
12. }
13. public class MyThread4 extends Thread{
14.     public MyThread4(String name){
15.         super(name);
16.     }
17.     @Override
18.     public void run() {
19.         for (int i = 0; i < 100; i++) {
20.             System.out.println(getName()+"-"+i);
21.         }
22.     }
23. }
24. 执行结果:
25. 飞机和坦克都可能先执行完毕，优先级不是绝对只是概率问题

复制代码

保卫线程：
          当非保卫线程执行完毕后，保卫线程就会结束。
  应用场景：
          比如qq两天，其中一个要发送文件给另一个人，聊天是线程1，传输文件时线程2，当线程1执行结束后，那么线程2也没有存在的必要了，线程2可以设置为保卫线程。
          
  
  线程生命周期 

 线程安全标题

  应用场景:
        某影戏院目前正在上映国产大片，共有100张票，而它又3个窗口买票，设计一个程序模拟影戏院买票。
           

1. public class demo7 {
2.     public static void main(String[] args) {
3.         ThreadMyRun tmr=new ThreadMyRun();
4.         Thread t1=new Thread(tmr);
5.         Thread t2=new Thread(tmr);
6.         Thread t3=new Thread(tmr);
7.         t1.setName("窗口1");
8.         t2.setName("窗口2");
9.         t3.setName("窗口3");
10.         t1.start();
11.         t2.start();
12.         t3.start();
13.     }
14. }

复制代码

  运行结果:会发现出现重复的票，也会有超出范围的票
  

  原因：

  1.打印会出现重复的票:
          三个线程，第一个线程执行完之后，会睡眠10毫秒，然后线程2这时候会抢占进程，然后睡眠10毫秒，然后第三个线程执行完之后，会睡眠10毫秒，一直在ticket++，末了都输出卖出ticket张票，所以这里出现了打印出现重复的票.
  2.超出范围的票
          当打印到99的时候，三个线程出现上面的环境，因为一直没有打印完，ticket++了三次，所以打印完之后才会出现再去判定票是否还满足100以内.打印了102、102、102
  
  
  怎么办理这个标题?
        当有线程在代码中执行时，就把它锁起来，只有当前线程执行完之后，其它线程才气进入，把共享数据的这段代码锁起来
同步代码块

        把利用共享数据的代码锁起来
格式：
        synchronized(锁){
                利用共享数据的代码。
}
特点1：锁默认打开，有一个线程进去了，锁自动关闭
特点2：内里的代码全部执行完毕，线程出来，锁自动打开
  

1. public class ThreadMyRun implements Runnable{
2.     int ticket=0;//这种创建方法 因为ThreadMyRun是传递的参数 只会创建一次
3.     @Override
4.     public void run() {
5.         while(true){
6.             try {
7.                 if (method()) break;
8.             } catch (InterruptedException e) {
9.                 e.printStackTrace();
10.             }
11.         }
12.     }
13.     private boolean method() throws InterruptedException {
14.         synchronized (ThreadMyRun.class){ /<strong>/1.不能写在while循环的外面，因为如果放在外面，只有第一个抢到运行优先权线程执行完while之后，才能第二个线程进入同步代码块
15. 2.同步代码块里的锁必须时唯一的，这里用的字节码文件，如果用几个线程用不同的锁，那么锁的意义也就没了</strong>
16.             if(ticket==100){
17.                 return true;
18.             }
19.             else{
20.                 Thread.sleep(100);
21.                 ticket++;
22.                 System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"票");
23.             }
24.         }
25.         return false;
26.     }
27. }

复制代码

运行结果:可以看到正常运行
  

  lock锁

提供了获得锁和释放锁的方法：lock()、unlock()
  

1. public class LockDemo extends Thread{
2.     static int ticket=0;
3.     static Lock lock=new ReentrantLock();//因为Lock是接口，需要创建实现类对象
4.     @Override
5.     public void run() {
6.         lock.lock();//加锁
7.         while(true){
8.             if(ticket==100){
9.                 break;
10.             }
11.             else{
12.                 try {
13.                     Thread.sleep(1000);
14.                     ticket++;
15.                     System.out.println(getName()+"正在卖第"+ticket+"张票");
16.                 } catch (InterruptedException e) {
17.                     e.printStackTrace();
18.                 } finally {
19.                     lock.unlock();//执行完毕之后释放锁
20.                 }
21.             }
22.         }
23.     }
24. }

复制代码

死锁

死锁是一种常见的标题，它发生在多个线程相互等候对方释放资源时，导致它们都无法继承执行。
一般锁的嵌套会出现这种标题。
生产者消费者标题

代码模拟： 
  

1. public class Cook extends Thread{
2.     @Override
3.     public void run() {
4.         while(true){
5.             synchronized (Desk.lock){
6.                 if(Desk.count==0){
7.                     break;
8.                 }
9.                 else{
10.                     if(Desk.foodFlag==1){
11.                         try {
12.                             Desk.lock.wait();
13.                         } catch (InterruptedException e) {
14.                             e.printStackTrace();
15.                         }
16.                     }
17.                     else{
18.                         System.out.println("厨师又做了一碗，还有");
19.                         Desk.foodFlag=1;
20.                         Desk.lock.notifyAll();//等待消费者
21.                     }
22.                 }
23.             }
24.         }
25.     }
26. }

复制代码

1. public class Foodie extends Thread{
2.     @Override
3.     public void run() {
4.         /*
5.         * 1.循环
6.         * 2.同步代码块
7.         * 3.共享数据是否到了末尾 到了末尾
8.         * 4.未到末尾
9.         * */
10.         while(true){
11.             synchronized (Desk.lock){
12.                 if(Desk.count==0){
13.                     break;
14.                 }
15.                 else{
16.                     if(Desk.foodFlag==0){//没有面条
17.                         try {
18.                             Desk.lock.wait();
19.                         } catch (InterruptedException e) {
20.                             e.printStackTrace();
21.                         }
22.                     }
23.                     else{
24.                         Desk.count--;
25.                         System.out.println("吃过正在吃面条,还能再吃"+Desk.count+"碗");
26.                         Desk.lock.notifyAll();//唤醒的是厨师
27.                         Desk.foodFlag=0;
28.                     }
29.                 }
30.             }
31.         }
32.     }
33. }

复制代码

1. package ThreadDemo;
3. public class Desk {
4.     /*
5.     控制生产者消费者的执行
6.      */
7.     //是否有面条 0有 1没有
8.     public static int foodFlag=0;
9.     //总个数
10.     public static int count=10;
11.     //上锁
12.     public static Object lock=new Object();
14. }

复制代码

1. public class demo9 {
2.     public static void main(String[] args) {
3.         Cook c=new Cook();
4.         Foodie f=new Foodie();
5.         c.setName("厨师");
6.         c.setName("吃货");
8.         c.start();
9.         f.start();
10.     }
11. }
12. 运行结果:

复制代码

  生产者消费者壅闭队列实现
  

1. public class <strong>Cook2</strong> extends Thread{
2.     ArrayBlockingQueue<String> queue;
3.     public Cook2(ArrayBlockingQueue<String>queue){
4.         this.queue=queue;
5.     }
6.     @Override
7.     public void run() {
8.         while(true){
9.             try {
10.                 queue.put("面条");
11.                 System.out.println("厨师放一碗面条");//这个是锁的外面
12.             } catch (InterruptedException e) {
13.                 e.printStackTrace();
14.             }
15.         }
17.     }
18. }

复制代码

1. public class <strong>Food2 </strong>extends Thread{
2.     ArrayBlockingQueue<String> queue;
3.     public Food2(ArrayBlockingQueue<String>queue){
4.         this.queue=queue;
5.     }
6.     @Override
7.     public void run() {
8.         while(true){
9.             try {
10.                 String food=queue.take();
11.                 System.out.println(food);
12.             } catch (InterruptedException e) {
13.                 e.printStackTrace();
14.             }
17.         }
18.     }
19. }

复制代码

1. public class demo10 {
2.     public static void main(String[] args) {
3.         ArrayBlockingQueue<String>queue=new ArrayBlockingQueue<>(1);<strong>//创建容量为1的阻塞队列
4. </strong>
5.         Food2 food2=new Food2(queue);
6.         Cook2 cook2=new Cook2(queue);
8.         food2.start();
9.         cook2.start();
10.     }
11. }

复制代码

线程6种状态

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。