JavaSE_day18:线程Thread

最新推荐文章于 2024-04-24 10:52:32 发布

陈小帅1019

最新推荐文章于 2024-04-24 10:52:32 发布

阅读量163

点赞数

本文链接：https://blog.csdn.net/qq_40174864/article/details/81592382

版权

线程：

今天又学习了JavaSE的另一块重要的知识点：线程。上课听的时候感觉琐碎的知识点很多，下来尽量还是整理下，日后忘了还能打开看一下复习复习。

线程：程序一进程为单位。而一个进程可以分为一个到多个线程。

首先，这个进程是可以查看的，CPU的情况，进程，线程都是可以查看的。（查线程：打开win+R，输入jconsole可以查看）

单核CPU：

操作系统有一个组件叫做任务调度器，将CPU的时间片分给不同的程序去使用，其实在微观上来说是串行的，不是并行的

。但是在宏观角度来看，可以说是并行的，因为执行的速率很快。当然多核CPU就可以真正实现微观上的并行操作。

那么来谈一谈，这个多核CPU并行操作他有什么好处呢？

首先，多线程，多进程可以让程序不被堵塞（单线程的情况下，一个程序在执行的时候其他程序都是在等着）

其次，程序不被堵塞，那么就发挥了多核CPU的优势，提供运作效率。

Java中的多线程：Thread 类

来看一下创建线程的方法：

方法一：

Thread thread= new Thread（）｛

public void run（）｛

//要执行的代码

//此处不能抛出检查异常，只能通过try-catch来手动处理

｝

｝；

thread.start（）；这句话就是要启动线程，上边仅仅只是创建了一个线程。

好，代码实现下：

public class ThreadDemo {
   public static void main(String[] args) {
       Thread thread = new Thread() {
           @Override
           public void run() {
               for(int i=0;i<5000;i++) {
                   System.out.println("...................panda..............");
               }
           }
       };
       thread.start();
   }
}

方法二：

把要创建的线程和代码分开

Runnable r = new Runnable（）｛

public void run（）｛

// 要执行的代码

//不能抛出检查异常，

｝

｝；

Thread thread =new Thread（r）；

thread.start（）；

代码实现：

public class ThreadDemo4 {
   public static void main(String[] args) {
       Runnable runnable = new Runnable() {
           @Override
           public void run() {
               System.out.println("panda...............");
           }};
           Thread thread = new Thread(runnable);
           thread.start();
           /*Runnable runnable2=()->System.out.println("panda2............");//拉姆达表达式
           Thread thread2 = new Thread(runnable2);
           thread2.start();*/
   }
}
既然上边我们说到线程Thread他是一个类，那么类就有他的方法，所以就来看一下 Thread类他有哪些方法呢？

Thread.Sleep(long n):n是毫秒值就是让这个线程休眠n毫秒。（静态方法用l类名直接调用）

Thread.currentThread():找到当前的线程。

（可以使用jconsole来查看Java进程中的线程的运行情况）

start（）：启动线程。如果调用两次或者多次启动方法，会出现illegalThreadStateException异常

join（）：等待线程休眠结束

join（long n）：最多等待n毫秒

直接调用run和使用start间接调用run的区别：

1）直接调用run，就是在主线程中执行了run，并没有执行新的线程

2）通过start间接调用就是，用Thread的对象thread来调用run方法，也就是通过新的线程来间接调用run方法

public class JoinDemo {
   static int r=0;
   public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread() {
           @Override
           public void run() {
               System.out.println("线程1开始了。。。。。。。。。。。");
               try {
                   Thread.sleep(3000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("线程1结束了。。。。。。。。。。。。");
               r=100;
           }
       };
       thread.start();
//       System.out.println("main线程开始了。。。。。。。");
//       thread.join(5000); //join（long n）：最多等待n毫秒
//       System.out.println("main线程结束了。。。。。。。。");
       thread.join();
       System.out.println(r);
   }
}

线程0中休眠了3秒，而主线程休眠5秒（被注释部分）当线程0结束之后，主线程不会在傻傻的在等待2秒，而是直接就会打印

打印结果如下：

* 线程1开始了。。。。。。。。。。。(3miao后打印下边两句)
* 线程1结束了。。。。。。。。。。。。
*100

如果没有被注释，则打印如下：

main线程开始了。。。。。。。 1
线程1开始了。。。。。。。。。。。 2
线程1结束了。。。。。。。。。。。。 3
main线程结束了。。。。。。。。 4
100 5

先打印1和2（无先后顺序）3秒之后在打印3、4、5（3.、4无顺序但是在5之前）

综述以及其他方法：

Thread.sleep（long n）：休眠n毫秒

Thread.currentThread（）：找到当前线程

start（）：线程的启动方法

thread.join（）：等待方法

thread.join（long n）：最多等待n毫秒

getName（）：获取线程名称

yield（）：谦让，如果两个线程同时进行，那么调用了yield的线程会相对谦让另一个线程（这里仅仅只是相对谦让，做不到绝对的谦让，所以并不能用此方法来使线程按照某种顺序来执行）

下来来介绍下另一种线程：守护线程，见名之意啊，守护主线程的嘛，一般在Java程序都是等待所有的线程全部结束了，然后才会结束。而这个守护线程比较特殊，首先特殊之处在于他是守护主线程的，其次呢，当主线程运行结束的时候，即使守护线程还没有运行完毕，他也会随着主线程的结束而结束。

那么一起来看下代码实现：

public class DaemonDemo {
   public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread() {
           @Override
           public void run() {
               System.out.println("守护线程开始............");
               for(int i=0;i<5000;i++) {
                   System.out.println("...........hello kitty.........");
               }
               try {
                   Thread.sleep(10000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("守护线程结束了.............");
           }
       };
       thread.setDaemon(true);
       thread.start();
       Thread.sleep(2000);
   }
}

这个程序中是让主线程休眠2秒钟，守护线程休眠10秒钟，那么这个程序就在2秒后执行完毕，也不再等待守护线程执行不执行

interrupt（）可以打断正在休眠的线程（包括join（） sleep（））：

public class InterruptDemo2 {
   public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread() {
           @Override
           public void run() {
               System.out.println(".....panda.....");
               try {
                   Thread.sleep(5000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("hhhhhhhh........");
           }
       };
       thread.start();
       Thread.sleep(1000);
       System.out.println("打断线程0 ..........");
   }
}
先打印 “.....panda..... ”，搁一秒打印 “打断线程0 ..........” 在搁一秒打印“ hhhhhhhh........”

线程并发：（Concurrent）

同步关键字，synchronized。

语法：

synchronized（对象）｛

要作为原子操作代码

｝

那么现在就来看一下具体的代码实现：

public class ConcurrentDemo2 {
static int i = 0;

   public synchronized static void add() {
       i++;
   }
   public synchronized static void sub() {
       i--;
   }
   public static void main(String[] args) throws InterruptedException {
       ConcurrentDemo2 obj = new ConcurrentDemo2();
       Thread thread = new Thread() {

           @Override
           public void run() {
               for (int x = 0; x < 1000; x++) {
                   obj.add();
               }
           }
       };
       Thread thread2 = new Thread() {

           @Override
           public void run() {
               for(int x=0;x<1000;x++) {
                   obj.sub();
               }
           }
       };
       thread.start();
       thread2.start();
       thread.join();
       thread2.join();
       System.out.println(i);
   }
}

或者第二种方法：

public class ConcurrentDemo {
   static int i = 0;
   static Object obj = new Object();
   static Object obj2 = new Object();
   public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread(() -> {
           for (int x = 0; x < 5000; x++) {
               synchronized (obj) {
                   i++;
               }
           }
       });
       Thread thread2 = new Thread(() -> {
           for (int x = 0; x < 5000; x++) {
               synchronized (obj) {
                   i--;
               }
           }
       });
       thread.start();
       thread2.start();
       thread.join();
       thread2.join();
       System.out.println(i);
   }
}
每个对象都有一个自己的monitor（监事器），当一个线程调用synchronized（对象），就相当进入了这个对象的监事器，要检查有没有owner，如果没有，次线程成为owner，但是如果已经有owner了，这个线程在entrySet的区域等待owner的位置空出来。

成为 Owner可以理解为获得了对象的锁，在竞争的时候，是非公平的，而且synchronized必须是进入同一个对象的monitor才有上述效果。

volatile易变的

可以用来修饰成员变量和静态成员变量，他可以防止线程从自己的告诉缓存中查找变量的值，必须到主存中获取他的值。

他保证的是变量再多线程之间的可见性，不能保证原子性

public class VolatileDemo2 {
/*volatile*/ static boolean a=true; ............................注释1
   public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread() {
           @Override
           public void run() {
               while(a) {
//                   System.out.println("............."); ..........................注释2
               }
           }
       };
       thread.start();
       Thread.sleep(5000);
       a=false;
   }
}
如果将注释1 和注释2去掉，那么这个程序就算是在主线程中让其休眠5秒，那么线程0中的while循环也不一定结束，因为while循环中没有输出语句，线程0每次在执行while循环语句的时候只会在自己高速缓存中看一下a的值有没有发生改变，因为再告诉缓存中没有即使更新a的值，所以就会发生死循环，那么只去掉注释1的话，不会发生上述情况，因为每次循环打印一句话，不会在高速缓存中看a的值。最好的情况下就是在静态常量的前边加上volatile关键字，就会使常量变成一个易变的量就是撤回1 的注释

下来我们来看一下synchronized的两种写法：

public synchronized void test（）｛｝

上边的就相当于：

public void test（）｛

synchronized（this）｛｝

｝

方法二：

public Test｛

public synchronized static void test（）｛

｝

相当于：

public Test｛

public static void test（）｛

synchronized（Test.class）

｝

锁的对象不同

线程死锁：

发生原因：

a线程获得A对象锁之后，又想获得B对象锁

b线程获得B对象锁之后，又想获得A对象锁

两者都持有对方想要的锁不放，所以两个一直在等待，就会出现线程死锁现象。

如下所示，就是这样，死锁问题：

public class DeadLockDemo {
   public static void main(String[] args) {
       Object A = new Object();
       Object B = new Object();
       Thread thread = new Thread() {
           @Override
           public void run() {
               synchronized (A) {
                   try {
                       Thread.sleep(1000);

                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   try {
                       A.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   synchronized (B) {
                       System.out.println(".....a.......");
                   }
               }
           }
       };
       Thread thread2 = new Thread() {
           @Override
           public void run() {
               synchronized (B) {
                   try {
                       Thread.sleep(300);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   synchronized (A) {
                       System.out.println(".......b......");
                       A.notify();
                   }
               }
           }
       };
       thread.start();
       thread2.start();
   }
}

检测死锁的工具jconsole

wait（）notify（）notifyAll（）都属于Object对象的方法

wait（）：等待

notify（）：唤醒

两者都是线程之间进行协作的手段

obj.wait():让Object监事器的线程等待

obj.notify():让object上等待的线程随机唤醒一个

obj.notifyAll():将object上等待的线程全部唤醒。

必须获得对象锁，才能使用这些方法

public class WaitNotifyDemo {
   public static void main(String[] args) {
       Object obj = new Object();
       Thread thread = new Thread() {
           @Override
           public void run() {
               System.out.println("Thread-0线程开始了");
               synchronized (obj) {
                   try {
                       obj.wait(); // 如果不唤醒，Obj将一直等待
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("Thread-0其他代码");
               }
           }
       };
       Thread thread2 = new Thread() {

           @Override
           public void run() {
               System.out.println("Thread-1线程开始了");
               synchronized (obj) {
                   try {
                       obj.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("Thread-1其他代码");
               }
           }
       };
       thread.start();
       thread2.start();
       try {
           Thread.sleep(2000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("唤醒一个线程");
       synchronized (obj) {
           obj.notify();
       }
   }
}

wait（）：方法实际是会释放对象的锁，进入waitSet等待区，从而让其他线程就会有机会获取对象的锁。无限制等待，知道notify为止

wait（long n）：有时限的等待，n毫秒后等待结束或者是被notify

sleep（long n）wait（long n）的区别：

1） sleep（）是Thread的方法，而wait（）是object的方法

2）sleep是不需要强制和synchronized配合使用，但是wait需要和synchronized一起用

3）sleep在休眠的时候不会释放对象锁，但是wait在等待的时候会释放对象锁

8. 线程的状态
NEW(新建) 线程刚被创建，但是还没有调用 start方法

RUNNABLE(可运行) 当调用了start() 方法之后

BLOCKED(阻塞) 当线程进入了monitor监视器区，处于entrySet里准备竞争锁的时候，处于阻塞状态

WAITING(等待) 当调用了对象的wait方法，或调用了线程对象的join方法，进入了WaitSet，处于等待状态

TIMED_WAITING 当调用wait(long n) join(long n) 进入了WaitSet，处于有限时的等待状态
当调用sleep(long n) 是让当前线程放弃cpu的时间片，睡眠一会

TERMINATED （终止）当线程代码运行结束

如何让两个线程以固定的顺序运行：

public class Test {
   static Object obj=new Object();
   static boolean run=true; //判断thread2是否执行过
   public static void main(String[] args) {
       Thread thread = new Thread() {
           @Override
           public void run() {
               synchronized(obj) {
                   while(run) {
                       try {
                           obj.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
               System.out.println(1);
           }
       };
       Thread thread2 = new Thread() {
           @Override
           public void run() {
               System.out.println(2);
               synchronized(obj) {
                   run=false;
                   obj.notify();
               }
           }
       };
       thread.start();
       thread2.start();
   }
}