AI 助理
备案控制台
开发者社区 安全 文章 正文

线程(二)

2024-09-24 24
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 线程(二)

一、线程控制中常用的方法：

①、join方法的使用，代码如下：

  1. package com.weizhaoyang.demo;

  3. /**
  4. * join方法的使用
  5. * 作用：让其主线程等待子线程完成后再执行主线程
  6. */
  7. public class ThreadJoin {
  8.    public static void main(String[] args) {
  9.        System.out.println("main thread start");
  10.        Thread T1 = new Thread(new MyRunnable(), "AAAA");
  11.        T1.start();
  12.        try {
  13.            T1.join();
  14.        } catch (InterruptedException e) {
  15.            e.printStackTrace();
  16.        }
  17.        System.out.println("main thread end");
  18.    }

  20.     static  class  MyRunnable implements Runnable{
  21.         public void run() {
  22.             for(int i=0;i<10;i++){
  23.                 System.out.println(Thread.currentThread().getName()+"执行中");
  24.             }
  25.         }
  26.     }
  27. }

运行的结果如下：

②、设置守护线程

例1、在java中常用的守护线程是GC垃圾回收器， 作用是给其他的线程提供服务的，当主线程程死亡，守护线程自动死亡，只要主线程没有死亡，守护线程会一直去守护它，代码如下：

  1. package com.weizhaoyang.demo;

  3. import java.io.IOException;

  5. /**
  6. * 测试守护线程
  7. */
  8. public class ThreadDaemon {
  9.    public static void main(String[] args) {
  10.        System.out.println("main  Thread start");
  11.        Thread thread = new Thread(new MyRunnable());
  12.        thread.setDaemon(true);//设置守护线程
  13.        thread.start();
  14.       /* try {
  15.            Thread.sleep(5000);
  16.        } catch (InterruptedException e) {
  17.            e.printStackTrace();
  18.        }*/
  19.        //I/O阻塞，等待主线程去输入，一旦输入，然后守护线程就结束了，否则就等待
  20.        try {
  21.            System.out.println("请输入内容");
  22.            System.in.read();
  23.        } catch (IOException e) {
  24.            e.printStackTrace();
  25.        }

  27.        System.out.println("main thread end");
  28.        System.out.println(thread.getState());
  29.    }
  30.    static  class  MyRunnable implements Runnable{
  31.        public void run() {
  32.            for(;;){
  33.                try {
  34.                    Thread.sleep(1000);
  35.                } catch (InterruptedException e) {
  36.                    e.printStackTrace();
  37.                }
  38.                System.out.println(Thread.currentThread().getName()+"执行GC操作准备.....");
  39.            }
  40.        }
  41.    }
  42. }

运行的结果如下：当输入内容和者敲回车的话，守护线程会立刻结束。

守护线程用的场景 ：比如某几秒钟想要统计人流量或者流量的数据，这时把它可以设置为守护线程，作用：为其非守护线程(主线程和其他的子线程)提供服务的。

三、sleep方法
主动进入阻塞状态，调用sleep方法，JDK5以后推荐使用TimeUtil枚举睡眠

四、yield方法

1、执行yield方法，让当前线程设置为就绪状态

2、当完成一个方法的时候，可以将处理器控制权让出去

3、不保证让出去，其他线程就能够马上得到控制权，可能自己又一次拿到了控制权

只是提高了其他的线程拿到时间片的概率提高。

  1. package com.weizhaoyang.demo;

  3. public class ThreadYield {
  4.    public static void main(String[] args) {
  5.          //接口的匿名参数
  6.         Thread t1=new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 for(int i=0;i<5;i++){
  10.                     System.out.println(Thread.currentThread().getName()+"执行"+i);
  11.                 }
  12.             }
  13.         },"AAAA");
  14.        Thread t2=new Thread(new Runnable() {
  15.            @Override
  16.            public void run() {
  17.                for(int i=0;i<5;i++){
  18.                    if(i==0){
  19.                        //当T2线程中的i=2的时候，t1让出来，让t2运行
  20.                        t1.yield();
  21.                    }
  22.                    System.out.println(Thread.currentThread().getName()+"执行"+i);
  23.                }
  24.            }
  25.        },"BBBB");
  26.        //启动线程
  27.        t1.start();
  28.        t2.start();
  29.        t1.yield();
  30.    }
  31. }

运行的结果如下：

五、线程的优先级：proiority，只是说让线程获取时间片的几率大大提高了

范围1-10，中间的优先级为5，推荐使用Thread的三个镜头常量，适应不同的操作系统。

代码如下：

  1. package com.weizhaoyang.demo;

  3. /**
  4. * 线程的优先级
  5. */
  6. public class ThreadPriority {
  7.    public static void main(String[] args) {
  8.        Thread t1=new Thread(new MyRunnable(),"AAAA");
  9.        Thread t2=new Thread(new MyRunnable1(),"BBBB");
  10.        t1.setPriority(Thread.MAX_PRIORITY);
  11.        t2.setPriority(Thread.MIN_PRIORITY);
  12.        t1.start();
  13.        t2.start();
  14.    }

  16.    static  class  MyRunnable implements Runnable{
  17.        public void run() {
  18.            for(int i=0;i<5;i++){
  19.                System.out.println(Thread.currentThread().getName()+" 执行中");
  20.            }

  22.        }

  24.    }
  25.    static  class  MyRunnable1 implements Runnable{
  26.        public void run() {
  27.            for(int i=0;i<5;i++){
  28.                System.out.println(Thread.currentThread().getName()+" 执行中");
  29.            }

  31.        }

  33.    }
  34. }

运行如下：线程优先级，提高线程优先于其他线程的几率，并不是按照你设定的去执行。

二、线程同步

当多个线程访问同一个资源时，加synchronized对象对资源进行加锁

①、制造一个线程安全问题的例子：沉睡的话 可以增大线程安全问题几率提高

  1. package com.weizhaoyang.safe;

  3. /**
  4. * 线程安全问题：多个线程共享同一个资源导致的
  5. */
  6. public class ThreadSafe1 {
  7.    public static void main(String[] args) {
  8.        //创建三个卖票窗口
  9.        MyThread  t1=new MyThread("窗口1");
  10.        MyThread  t2=new MyThread("窗口2");
  11.        MyThread  t3=new MyThread("窗口3");
  12.        t1.start();
  13.        t2.start();
  14.        t3.start();
  15.    }
  16.    static   class MyThread  extends Thread{
  17.        public MyThread(String  name){
  18.            super(name);
  19.        }
  20.        //让所有的实例共享这个资源
  21.        private static int  count=10;
  22.        @Override
  23.        public void run() {
  24.             while(count>0){
  25.                 try {
  26.                     Thread.sleep(500);
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.                 String tname = Thread.currentThread().getName();
  31.                 System.out.println(tname+"卖出了"+(count--)+"票");
  32.             }
  33.        }
  34.    }

运行结果如下：这就是在睡眠的时候出现了线程的安全性问题，本来是10张票，却卖出12张票。也就是说在阻塞的过程中，窗口1，2同时拿到了还没有减的这张票（0），而且这个“0”票是超卖的票，原因当窗口3进来拿到票了，而没有减，当窗口2进来的时候，把票减了，这时窗口2和窗口1都拿到了“0”票，这就出现了线程的安全性的问题，没有保证原子性。

如果不加static的话，三个窗口都会分别卖出10张票，因为每创建一个对象就会有一个count变量为10的成员，属于实例中的成员，局部变量不会出现线程安全的问题。

上面使用的是继承的方式，如果用接口的话，更好，因为接口是多实现的，继承是单继承的

例子②，代码如下：

  1. package com.weizhaoyang.safe;

  3. public class ThreadSafe2 {
  4.    //让所有的实例共享这个资源
  5.    private static int  count;

  7.    public static void main(String[] args) {
  8.        Thread t1=new Thread(new MyThread());
  9.        Thread t2=new Thread(new MyThread());
  10.        t1.start();
  11.        t2.start();
  12.        try {
  13.            t1.join();
  14.            t2.join();
  15.        } catch (InterruptedException e) {
  16.            e.printStackTrace();
  17.        }
  18.        System.out.println("count="+count);
  19.    }
  20.    static   class MyThread  implements Runnable{
  21.        @Override
  22.        public void run() {
  23.           for(int i=0;i<1000000;i++){
  24.               count++;
  25.           }
  26.        }
  27.    }
  28. }

运行的结果如下：这也是线程的安全的问题，说明很多数据出现了线程的安全性的问题。

解决方案：

用到线程同步操作：既然保证count的原子性

synchronized有三种加锁的方式，在jdk1.5的时候用的比较多，但是现在已经被并发编程的包给替代掉了

1、同步块：

synchronized：保证在同一个时间片上不能有其他线程同时执行 。

当其中一个线程拿到锁之后，就执行count++,然后执行完，就释放锁，然后另一个线程来执行，否则继续等待锁。并且仅有一个线程拿到锁。

同步块里传的参数是对象，代表锁的标识。

  1. package com.weizhaoyang.sync;

  3. import com.weizhaoyang.safe.ThreadSafe2;

  5. /**
  6. * 使用同步块解决线程安全的问题
  7. */
  8. public class SyncBlock {
  9.    //让所有的实例共享这个资源
  10.    private static int  count;
  11.    private  static  Object lock=new Object();

  13.    public static void main(String[] args) {
  14.        Thread t1=new Thread(new MyThread());
  15.        Thread t2=new Thread(new MyThread());
  16.        t1.start();
  17.        t2.start();
  18.        try {
  19.            t1.join();
  20.            t2.join();
  21.        } catch (InterruptedException e) {
  22.            e.printStackTrace();
  23.        }
  24.        System.out.println("count="+count);
  25.    }
  26.    static   class MyThread  implements Runnable{
  27.        @Override
  28.        public void run() {
  29.            for(int i=0;i<1000000;i++){
  30.                synchronized (lock){
  31.                    count++;
  32.                }
  33.            }
  34.        }
  35.    }
  36. }

结果如下：

2、在实例上加锁

  1. package com.weizhaoyang.sync;

  3. /**
  4. * 使用同步关键字枷锁对象的实例方法
  5. */
  6. public class SynInstance {
  7.    //让所有的实例共享这个资源
  8.    private static int  count;
  9.    public static void main(String[] args) {
  10.        MyThread myThread=new MyThread();

  12.        Thread t1=new Thread(myThread);
  13.        Thread t2=new Thread(myThread);
  14.        t1.start();
  15.        t2.start();
  16.        try {
  17.            t1.join();
  18.            t2.join();
  19.        } catch (InterruptedException e) {
  20.            e.printStackTrace();
  21.        }
  22.        System.out.println("count="+count);
  23.    }
  24.    static   class MyThread  implements Runnable{
  25.        public  synchronized   void  trace(){
  26.                count++;
  27.        }
  28.        @Override
  29.        public void run() {
  30.            for(int i=0;i<1000000;i++){
  31.                   trace();
  32.            }
  33.        }
  34.    }
  35. }

运行的结果如下：

3、类锁，代码如下：

  1. package com.weizhaoyang.sync;

  3. /**
  4. * 使用同步关键字枷锁对象的实例方法
  5. */
  6. public class SynInstance {
  7.    //让所有的实例共享这个资源
  8.    private static int  count;
  9.    public static void main(String[] args) {


  12.        Thread t1=new Thread(new MyThread());
  13.        Thread t2=new Thread(new MyThread());
  14.        t1.start();
  15.        t2.start();
  16.        try {
  17.            t1.join();
  18.            t2.join();
  19.        } catch (InterruptedException e) {
  20.            e.printStackTrace();
  21.        }
  22.        System.out.println("count="+count);
  23.    }
  24.    static   class MyThread  implements Runnable{
  25.        public  static synchronized   void  trace(){
  26.                count++;
  27.        }
  28.        @Override
  29.        public void run() {
  30.            for(int i=0;i<1000000;i++){
  31.                   trace();
  32.            }
  33.        }
  34.    }
  35. }

运行的结果如下：

一般使用类锁比较好

总结：不管在对象上加锁，类上加锁，实例上加锁，只要持有的是同一把锁就可以解决线程 安全的问题,明天写重入锁，非公平，公平，读写锁。

文章标签：
安全
Java
1176112968452250
目录
相关文章
灰灰快醒醒
|
7月前
|
Java Linux API
线程的认识
线程的认识
灰灰快醒醒
47 0
1176112968452250
|
3月前
|
监控 安全 Java
线程(一）
线程(一）
1176112968452250
50 5
会飞翔的羊
|
7月前
|
存储 安全 Java
C++线程浅谈
C++线程浅谈
会飞翔的羊
49 1
王有志
|
算法 NoSQL Java
02.关于线程你必须知道的8个问题（上）
大家好，我是王有志，欢迎来到《Java面试都问啥？》。 今天我们来一起看看在面试中，关于线程各大公司大都喜欢问哪些问题。
王有志
107 1
02.关于线程你必须知道的8个问题（上）
大汉学友
|
Java
线程理解
个人学习理解
大汉学友
81 0
EmotionFlying
|
传感器 存储 自动驾驶
（6）线程
（6）线程
EmotionFlying
102 0
lgr5ydyshhwik
|
缓存 监控 Java
线程
多线程
lgr5ydyshhwik
111 0
游客rzjm3y57ilfuu
线程睡眠
Thread.sleep方法会导致当前线程暂停执行一段指定的时间...
游客rzjm3y57ilfuu
293 0
毛球饲养员
|
PyTorch 算法框架/工具 Python
几个常用线程的
1 OMP_NUM_THREADS=1 export OMP_NUM_THREADS 在服务器上跑PyTorch 程序的列位不要把cpu占满 修改这个环境变量降低你们的cpu使用率 （因为pytorch默认是能用多少线程就用多少的） 在python代码中: # 选择显卡 os.
毛球饲养员
5885 0
推荐码发放
|
调度 C++ 存储
C++11线程使用总结
C++11线程使用总结 std::thread 在 <thread> 头文件中声明，因此使用 std::thread 需包含 <thread> 头文件。 <thread> 头文件摘要 <thread> 头文件声明了 std::thread 线程类及 std::swap (交换两个线程对象)辅助函数。
推荐码发放
1614 0