javaagent获取所有java进程的pid

转载

编程小达人之心 2024-10-14 16:20:22

文章标签 线程 java System i++ 优先级 文章分类 Java 后端开发

线程和进程

线程开发

继承Thread类
实现Runnable接口

示例
两种方式对比

线程的状态
线程的调度与控制
线程优先级
sleep和join还有yeild

Threadsleep
Threadjoin
Threadyield
sleepjoinyeild关系

interrupt中断

如何正确的停止一个线程

为什么需要同步
线程同步
使用线程同步

线程同步后的状态
为每一个线程创建一个对象来解决线程安全问题

死锁

解决死锁
解决死锁的案例

线程状态
守护线程

守护服务线程线程示例

线程和进程

进程：在操作系统中能（同时）运行多个任务（程序），每一个应用程序就是进程。
线程：在一个程序中同时运行额多个独立流程，每一个独立的流程就是一个线程。
每一个Java程序都至少有一个线程–主线程，当一个Java程序启动时，JVM会创建这个主线程，并且在这个主线程上调用main()方法。
线程并发：多个线程同时执行（多个线程轮流分配cpu的时间片，并不是真正的同时执行)。

线程开发

线程开发有两种方式：

继承Thread类
实现Runnable接口

继承Thread类

继承Thread类开发线程

用户定义一个类继承Thread类
覆盖run方法
运行线程

class MyThread extends Thread{
     public void run(){
         for(int i =1; i<=1000; i++) {
             System.out.println(i+"$$$");
         }
    }
}
class MyThread2 extends Thread{
    public void run() {
        for(int i=1; i<=1000; i++) {
            System.out.println(i+"###");
        }
    }
}

public class TestThread {
        public static void main(String args[]) {
            Thread t1 = new MyThread1();
            Thread t2 = new MyThread2();
            //启动线程，输出顺序是随机的
            t1.start();
            t2.start();
        }
    }

实现Runnable接口

Runnable接口开发线程

用户开发一个类实现Runnable接口
实现run();
运行线程
Runnable target = newMyRunnable2();
Thread t2 = new Thread(target);

示例

class MyThread1 extends Thread {
        public void run() {
            for(int i = 1; i<=1000; i++ ) {
                System.out.pintln(i+"$$$");
            }
        }
    }
    class MyRunnable2 implements Runnable {
        public void run() {
            for(int i = 1; i<=1000; i++) }
                System.out.println(i+"###");
            }
        }
    }
    public class TestThread {
        //第一种方式
        Thread t1 = new MyRunnable1();
        //第二种方式
        Runnable target = new MyRunnale2();
        Thread t2 = new Thread(target);
        t1.start();
        t2.start();
    }
}

两种方式对比

继承Thread上面向对象的编程方式
实现Runnable接口解决了单一继承的限制
二者都可采用匿名内部类的方式，如果线程只在一处使用，可以选择这种方式，但是可读性较差。

new Thread() {
     @Override
     public void run() {
         for(int i = 1; i<=1000; i++) {
             System.out.println(i+"$$$");
        }
    }
}.start();

new Thread(new Runnable() {
    @Overrider
    public void run() {
        for(int i = 1; i<=1000; i++) {
            System.out.println(i+"###");
        }
    }
}).start();

线程的状态

线程的状态分为5种，初始、可运行、运行、阻塞、以及终止等。

线程的调度与控制

通常我们的计算机知识一个CPU，CPU在某一个时刻只能执行一条指令，线程知识得到CPU时间片，也就是使用权，才可以执行指令。在单CPU的机器上线程不是并行运行的，只有在多个CPU的使用权，目前按有两种调度模型：分时调度模型和抢占式调度模型，Java使用抢占式调度模型。

分时调度模型，所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU时间片。
抢占式调度模型，优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个。

线程优先级

线程优先级主要分三种

MAX_PRIORITY(最高级);
MIN_PRIOITY(最低级);
NOM_PRIORITY(标准)默认；

public class ThreadTest04 {
    public static void main(String[] args) {
        Runnable r1 = new Processor();
        Thread t1 = new Thread(r1, "t1");
        //设置线程的优先级，线程启动后不能再次设置优先级
        //必须在启动前设置优先级
        //设置最高优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        //启动线程
        t1.start();

        //取得线程名称
        //System.out.println(t1.getName());

        Thread t2 = new Thread(r1, "t2");
        //设置最低优先级
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
            System.out.println(Thread.currentThread().getName());
    }   
}

class Processor implements Runnable {
           public void run() {
              for (int i=0; i<100; i++) {
                     System.out.println(Thread.currentThread().getName() + "," + i);
              } 
            }   
    }
    /**
     *从输出结果应该看可以看出，
     *优先级高的线程（t1）会得到的
     *CPU时间多一些，优先执行完成
     **/

sleep和join还有yeild

Thread.sleep

sleep设置休眠的时间,单位毫秒，当一个线程遇到sleep的时候，就会睡眠，进入到阻塞状态,放弃CPU，腾出cpu时间片，给其他线程用，所以在开发中通常我们会这样做，使其他的线程能够取得CPU时间片，当睡眠时间到达了，线程会进入就绪状态，得到CPU时间片继续执行，如果线程在睡眠状态被中断了，将会抛出IterruptedException

public class ThreadTest05 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            Thread t2 = new Thread(r1, "t2");
            t2.start();
        }   
    }

    class Processor implements Runnable {   
        public void run() {
            for (int i=0; i<100; i++) {
        System.out.println(Thread.currentThread().getName() + "," + i);
            if (i % 10 == 0) {
            try {
                //睡眠100毫秒，主要是放弃CPU的使用，将CPU时间片交给其他线程使用
                Thread.sleep(100);
            }catch(InterruptedException e) {
                e.printStackTrace();    
            }
        }
    }   
}

}

Thread.join

当前线程可以调用另一个线程的join方法，调用后当前线程会被阻塞不再执行，直到被调用的线程执行完毕，当前线程才会执行

public class ThreadTest07 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            try {
                t1.join();
            }catch(InterruptedException e) {
                    e.printStackTrace();    
            }
            System.out.println("------main end-------");
        }   
}

class Processor implements Runnable {
        public void run() {
            for (int i=0; i<10; i++) {
                System.out.println(Thread.currentThread().getName() + "," + i);
            }   
    }   
}

Thread.yield

它与sleep()类似，只是不能由用户指定暂定多长时间，并且yield()方法只能让同优先级的西安城有执行的机会。

public class ThreadTest06 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            Thread t2 = new Thread(r1, "t2");
            t2.start();
        }   
    }
    class Processor implements Runnable {
        public void run() {
            for (int i=0; i<100; i++) {
                System.out.println(Thread.currentThread().getName() + "," + i);
                if (i % 10 == 0) {
                    System.out.println("--------------");
                    //采用yield可以将CPU的使用权让给同一个优先级的线程
                    Thread.yield();
            }
        }   
    }   
}

sleep、join、yeild关系

sleep()使当前线程进入停滞状态，所以执行sleep的线程在指定的时间内肯定不会执行；sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会。
join方法也会导致线程阻塞

特点：如果当前线程中调用了另外一个线程的join方法，单签线程会立即阻塞，直到另外一个线程运行完成。

yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，yield()只能使同优先级的线程有执行的机会。

interrupt(中断)

如果我们的线程正在睡眠，可以采用interrupt进行中断

public class ThreadTest08 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            try {
                //设置为500毫秒，没有出现中断异常，因为500毫秒之后再次调用t1.interrupt()时，
                //此时的睡眠线程已经执行完成
                //如果sleep的时间设置的小一些，会出现中断异常，因为存在睡眠线程
                Thread.sleep(500);
            }catch(Exception e) {
                e.printStackTrace();
            }
        //中断睡眠中的线程
        t1.interrupt();
    }   
}

class Processor implements Runnable {   
    public void run() {
        for (int i=1; i<100; i++) {
            System.out.println(Thread.currentThread().getName() + "," + i);
            if (i % 50 == 0) {
                try {
                    Thread.sleep(200);  
                }catch(Exception e) {
                    System.out.println("-------中断-------");
                    break;              
                }
            }
        }   
    }   
}

如何正确的停止一个线程

通常定义一个标记，来判断标记的状态停止线程的执行。

public class ThreadTest09 {
        public static void main(String[] args) {
            //Runnable r1 = new Processor();
            Processor r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

        try {
            Thread.sleep(20);
        }catch(Exception e) {}
            //停止线程
            r1.setFlag(true);
        }   
    }
    class Processor implements Runnable {   
        //线程停止标记，true为停止
        private boolean flag;

        public void run() {
            for (int i=1; i<100; i++) {
                System.out.println(Thread.currentThread().getName() + "," + i);
                //为true停止线程执行
                if (flag) {
                    break;
                }
            }   
        }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }   
}

为什么需要同步

【示例代码】，取得0~10的和采用相同的线程对象启用两个线程进行计算（共享一个对象启动两个线程）

public class ThreadTest10 {
            public static void main(String[] args) {
                Runnable r1 = new Processor();
                Thread t1 = new Thread(r1, "t1");
                t1.start();

                Thread t2 = new Thread(r1, "t2");
                t2.start();

        }   
    }
    class Processor implements Runnable {   
            public void run() {
                //定义局部变量s，作为累加变量
                int s = 0;
                for (int i=0; i<10; i++) {
                    s+=i;
                }   
            System.out.println(Thread.currentThread().getName() + ", s=" + s);
        }
}

以上t1和t2并发执行，s为每个线程的局部变量，位于各自的栈帧中，因为栈帧中的数据是不会互相干扰的，所有计算结果都为45

线程同步

【示例代码】，取得0~10的和采用两个线程进行计算，将s改为成员变量(共享一个对象启动两个线程)

public class ThreadTest11 {

        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            Thread t2 = new Thread(r1, "t2");
            t2.start();

    }   
}
class Processor implements Runnable {
    //定义成员变量s，作为累加变量    
    private int s = 0;  
    public void run() {
        for (int i=0; i<10; i++) {
            s+=i;
        }   
        System.out.println(Thread.currentThread().getName() + ", s=" + s);
    }
}

这回两个线程的结果不一致了。为什么出现以上的问题，因为共享了同一个对象的成员变量s，两个线程同时对其进行操作，所以产生了问题，此时称为此时Processor为线程不安全的，如果想得到正确的结果，必须采用线程同步，加锁，该变量才能共享使用

产生数据不一致的原因

多个线程并发访问了同一个对象，如果破坏了不可分割的操作，从而就会造成数据不一致

临界资源
原子操作
被多线程并发访问时如果一个对象有可能出现数据不一致的问题，那么这个对象称为线程不安全的对象

使用线程同步

线程同步，指某一个时刻，指允许一个线程来访问共享资源，线程同步其实是对对象加锁，如果对象中的方法都是同步方法，那么某一时刻只能执行一个方法，采用线程同步解决以上的问题，我们只要保证线程1操作s时，线程2不允许操作即可，只有线程1使用完成s后，再让线程2使用s变量。

public class ThreadTest12 {
    public static void main(String[] args) {
        Runnable r1 = new Processor();
        Thread t1 = new Thread(r1, "t1");
        t1.start();     
        Thread t2 = new Thread(r1, "t2");
        t2.start();
    }   
}
class Processor implements Runnable {
    //定义成员变量s，作为累加变量    
    private int s = 0;  
    //synchronized是对对象加锁,采用synchronized同步最好只同步有线程安全的代码
    //可以优先考虑使用synchronized同步块因为同步的代码越多，执行的时间就会越长，
    //其他线程等待的时间就会越长影响效率
    //public synchronized void run() {
        //使用同步块
        synchronized (this) { 
            for (int i=0; i<10; i++) {
                s+=i;
            }   
            System.out.println(Thread.currentThread().getName() + ", s=" + s);
            s = 0;
        }
    }
}

执行正确，以上示例，如果不采用线程同步如何解决？可以让每个线程创建一个对象，这样在堆中就不会出现对象的状态共享了，从而可以避免线程安全问题

线程同步后的状态

javaagent获取所有java进程的pid_线程

为每一个线程创建一个对象来解决线程安全问题

public class ThreadTest13 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();
            //再次创建Processor对象，每个线程拥有自己的对象
            Runnable r2 = new Processor();
            Thread t2 = new Thread(r2, "t2");
            t2.start();
        }   
    }
    class Processor implements Runnable {
        //定义成员变量s，作为累加变量    
        private int s = 0;
        public void run() {
            for (int i=0; i<10; i++) {
                s+=i;
            }   
            System.out.println(Thread.currentThread().getName() + ", s=" + s);
            s = 0;
        }
    }

死锁

synchronized(a){
            ...//1   
          synchronized(b){
           }
        }
        synchronized(b){
            ... //2
          synchronized(a){
           }
        }

解决死锁

一般我们借助于线程的通信解决死锁问题

synchronized(a){
        ...//1   
      wait();
      synchronized(b){
       }
    }
    synchronized(b){
        ... //2
      synchronized(a){
            notify();
       }
    }

解决死锁的案例

javaagent获取所有java进程的pid_优先级_02

线程状态

javaagent获取所有java进程的pid_线程_03

守护线程

从线程分类可以分为：

用户线程(以上讲的都是用户线程)
守护线程。守护线程是这样的，所有的用户线程结束生命周期，守护线程才会结束生命周期，只要有一个用户线程存在，那么守护线程就不会结束，例如java中著名的垃圾回收期就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。

public class DaemonThreadTest01 {
    public static void main(String[] args) {
        Runnable r1 = new Processor();
        Thread t1 = new Thread(r1, "t1");
        t1.start();

        for (int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName() + ", " + i);
        }

        System.out.println("主线程结束！！！");
    }   
}

class Processor implements Runnable {

    public void run() {
        for (int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName() + ", " + i);
        }   
    }
}

主线程执行结束了，但用户线程仍然将数据打印出来了

守护（服务线程）线程示例

public class DaemonThreadTest02 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            //将当前线程修改为守护线程，在线程没有启动时可以修改以下参数
            t1.setDaemon(true);
            t1.start();
            for (int i=0; i<10; i++) {
                System.out.println(Thread.currentThread().getName() + ", " + i);
            }
            System.out.println("主线程结束！！！");
        }   
    }
    class Processor implements Runnable {
        public void run() {
            for (int i=0; i<10; i++) {
                System.out.println(Thread.currentThread().getName() + ", " + i);
            }   
        }
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：多线程java保持事务一致性

下一篇：springboot针对neo4j进行增删改查

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

javaagent获取所有java进程的pid

javaagent获取所有java进程的pid

线程和进程

线程开发

继承Thread类

实现Runnable接口

示例

两种方式对比

线程的状态

线程的调度与控制

线程优先级

sleep和join还有yeild

Thread.sleep

Thread.join

Thread.yield

sleep、join、yeild关系

interrupt(中断)

如何正确的停止一个线程

为什么需要同步

线程同步

使用线程同步

线程同步后的状态

为每一个线程创建一个对象来解决线程安全问题

死锁

解决死锁

解决死锁的案例

线程状态

守护线程

守护（服务线程）线程示例

51CTO博客