Thread의 정의와 일반적인 메소드

Thread에 대한 예비 연구

머리말

과거에는 모두가 단일 스레드 프로그램을 작성했고, 모든 호출 방법은 메인 함수에서 단일 스레드 가져오기를 사용하는 것과 마찬가지로 효율성이 특히 낮다는 것을 분명히 알 수 있습니다. python. 웹사이트에 올라가면 데이터 양이 너무 많아 피를 토할 수 있습니다. 오늘은 Java의 동시 프로그래밍 및 멀티스레딩에 대한 학습을 ​​살펴보겠습니다.

스레드 생성하기

다양한 방법이 있습니다. Thread 클래스를 상속하고 Runnable 인터페이스를 구현하는 등 스레드 메소드... 생성된 메소드를 자세히 살펴보겠습니다

Thread 상속

Thread를 상속하면 를 직접 호출할 수 있는 이유 > start() 메소드는 스레드를 시작합니다. start() 자체가 Thread의 메소드, 즉 Thread의 start() 메소드를 상속하므로 이 클래스의 객체입니다. start()를 호출할 수 있습니다. 스레드 시작Thread可以直接调用start()方法启动线程呢，因为start()本身就是Thread的方法，也就是继承了Thread的start()方法，因此这个类的对象可以调用start()启动线程

//继承Threadpublic class MyThread extends Thread {    public void run() {for (int i = 0; i < 10; i++) {
            System.out.println(this.getName()+"正在跑");
        }
    }
}public class Test{public static void main(String[] args)
    {
        Mythread t1=new MyThread();   //创建对象t1.start();     //启动线程}
}

注意: 继承Thread类的创建方法一个对象只能创建一个线程，并不能多个线程共用一个对象，只能一个线程对应一个对象，因此我们来看看实现Runnable接口的类来实现多个线程共享同一个对象

实现Runnable接口

//实现Runnable接口public class Demo implements Runnable {  @Overridepublic void run() {for(int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+"正在跑");
        }

    }
}//测试类public class Test{public static void main(String[] args)
    {
        Demo d=new Demo();  //创建对象Thread thread1=new Thread(d); //为对象创建一个线程Thread thread2=new Thread(d);   //创建另外一个线程//同时启动两个线程thread1.start();
        thread2.start();
    }
}

从上面可以清楚的看到实现Runnable接口的类一个对象可以供多个线程共享，并不像继承Thread类只为一个线程使用

简便的创建方法

直接在main方法中创建，如果创建的普通类的对象在外面，那么必须是final修饰，可以实现多个线程同时共享一个对象，这个和实现Runnable接口一样，这时候就要控制同步条件了，如果在run方法中定义对象，那么，就是一个线程对应一个对象,这个就和继承Thread类一样的效果。所以可以根据条件自由选择

//普通的一个类public class Simple {public void display()
    {for(int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+"正在跑");
        }
    }
}//线程测试类public class Test {public static void main(String[] args) {    //如果在外面必须使用final，当然也可以直写在run方法中,不过写在外面可以实现多个线程共享一个对象//写在run方法中当前对象只能为一个线程使用，和继承Thread类一样的效果final Simple simple=new Simple(); 
        
        //下面创建使用同一个对象创建同两个线程，实现多个线程共享一个对象，和实现Runnable接口一样的效果Thread t1=new Thread(){public void run() {
                simple.display();
            };
        };
        
        Thread t2=new Thread(){public void run() {
                simple.display();
            };
        };        //启动这两个线程t1.start();   
        t2.start();
    }}

常用的方法

• static void sleep(long mils) 使正在运行的线程休眠mils毫秒，但是这里需要注意的是如果线程加了锁，那么使线程休眠并不会释放锁

• String getName() 得到线程的名称，上面的程序中已经使用了这个方法

• void setName(String name) 设置正在运行的线程的名字为name

• start() 启动线程，线程的创建并不意味着线程的启动，只有调用start()方法线程才是真正的开始运行

• long getId() 返回线程的标识符

• run() 线程执行的代码都放在run()方法中，在run方法中的调用是有序的，都是按照程序运行的顺序开始执行

使用

下面使用上面的方法创建一个实例

//线程的类，继承Threadpublic class MyThread1 extends Thread {public void run() { // 重载run方法，并且在其中写线程执行的代码块for (int i = 0; i < 10; i++) {// 获取线程的id和nameSystem.out.println("Thread-Name:   " + this.getName()
                    + "   Thread-id:    " + this.getId());try {this.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}//线程测试的类public class Test {public static void main(String[] args) {
        MyThread1 t1 = new MyThread1(); // 创建线程t1.setName("第一个线程"); // 设置线程的名字MyThread1 t2 = new MyThread1();
        t2.setName("第二个线程");

        t1.start(); // 启动线程，开始运行t2.start();

    }
}

• void join() 等待该线程终止才能运行其他的线程

• void join(long mils) 等待该线程的时间为mils毫秒，一旦过了这个时间其他线程正常执行

使用

//线程类public class MyThread1 extends Thread {public void run() { // 重载run方法，并且在其中写线程执行的代码块for (int i = 0; i < 10; i++) {// 获取线程的id和nameSystem.out.println("Thread-Name:   " + this.getName()
                    + "   Thread-id:    " + this.getId());try {this.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}//测试类public class Test {public static void main(String[] args) {
        MyThread1 t1 = new MyThread1(); // 创建线程t1.setName("第一个线程"); // 设置线程的名字t1.start(); // 启动线程，开始运行try {
            t1.join();   //阻塞其他线程，只有当这个线程运行完之后才开始运行其他的线程} catch (InterruptedException e) {
            e.printStackTrace();
        }for (int i = 0; i < 10; i++) {
            System.out.println("主线程正在运行");
        }

    }
}//输出结果/*Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行 */

• getPriority() 得到当前线程优先级

• setPriority(int num) 更改线程的优先级(0-10)默认的是5，优先级越高获得cpu资源的几率就会越高

使用

//线程类public class MyThread1 extends Thread {public void run() { // 重载run方法，并且在其中写线程执行的代码块for (int i = 0; i < 10; i++) {// 获取线程的id和nameSystem.out.println("Thread-Name:   " + this.getName()
                    + "   Thread-id:    " + this.getId());try {this.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}//测试类public class Test {public static void main(String[] args) {
        MyThread1 t1 = new MyThread1(); // 创建线程t1.setName("第一个线程"); // 设置线程的名字MyThread1 t2 = new MyThread1();
        t2.setName("第二个线程");

        t2.setPriority(8);   //设置第二个线程的优先级为8，第一个线程的优先级为5(是默认的)t1.start();
        t2.start();

    }
}/* * 从上面的运行结果可以看出大部分的第二个线程都是在第一个线程之前开始执行的，也就是说优先级越高获得cpu执行的几率就越大 * /

• setDaemon(boolean) 是否设置为守护线程，如果设置为守护线程，那么主线程销毁守护线程也会随之销毁

• isDaemon()

//测试类public class MyThread1 extends Thread {public void run() { // 重载run方法，并且在其中写线程执行的代码块for (int i = 0; i < 10; i++) {// 获取线程的id和nameSystem.out.println("Thread-Name:   " + this.getName()
                    + "   Thread-id:    " + this.getId());try {
                Thread.sleep(1000);  //休眠一秒，方便主线程运行结束} catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}public class Test {public static void main(String[] args) {
        MyThread1 t1 = new MyThread1(); // 创建线程t1.setName("第一个线程"); // 设置线程的名字t1.setDaemon(true);
        t1.start();for (int i = 0; i < 1; i++) {
            System.out.println(i);
        }

    }
}//结果：/* 0123456789Thread-Name:   第一个线程   Thread-id:    9*//* * 从上面的结果可以看出，一旦主线程结束，那么守护线程就会自动的结束 *

참고: Thread 클래스의 생성 방법을 상속합니다. 객체는 하나의 스레드만 생성할 수 있고 여러 스레드를 생성할 수 있습니다. 하나의 스레드는 하나의 개체에 대응할 수 없으므로 동일한 개체를 공유하는 여러 스레드를 구현하기 위해 Runnable 인터페이스를 구현하는 클래스를 살펴보겠습니다.

Runnable 인터페이스 구현

rrreee

🎜🎜위에서 명확하게 알 수 있듯이 Runnable 인터페이스를 구현하는 클래스의 객체는 하나의 스레드에서만 사용하는 Thread 클래스를 상속받는 것과 달리 여러 스레드에서 공유할 수 있습니다🎜🎜🎜 main 메소드에서 직접 생성하는 간편한 방법🎜🎜🎜. 생성된 일반 클래스 객체가 외부에 있는 경우 최종 수정해야 합니다. 여러 스레드가 동시에 객체를 공유할 수 있습니다. 이때, 동기화 조건을 제어하기 위해 run 메소드에 객체를 정의하면 하나의 스레드가 하나의 객체에 대응되며 이는 Thread 클래스를 상속받은 것과 동일한 효과를 갖습니다. 그래서 조건에 따라 자유롭게 선택하시면 됩니다🎜🎜🎜rrreee🎜🎜자주 사용하는 방법🎜🎜<ul class=" list-paddingleft-2"><li>🎜<code>static void sleep(long mils) 스레드는 1000분의 1초 동안 휴면 상태입니다. 그러나 여기서 주목해야 할 점은 스레드가 잠겨 있으면 스레드를 휴면 상태로 해도 잠금이 해제되지 않는다는 것입니다🎜🎜🎜🎜🎜

• 🎜String getName() 스레드 이름을 가져옵니다. 이 메소드는 위 프로그램🎜🎜🎜🎜🎜
  🎜void setName( String name) 실행 중인 스레드의 이름을 name🎜🎜🎜🎜🎜
  • 🎜start로 설정합니다. () 스레드를 시작합니다. 스레드가 생성되었다고 해서 스레드가 시작되는 것은 아닙니다. start() 메서드가 호출되어야 스레드가 실제로 실행되기 시작합니다🎜🎜🎜🎜🎜
    • 🎜long getId () 스레드의 식별자를 반환합니다 🎜🎜🎜🎜🎜
      • 🎜run() 스레드에 의해 실행되는 코드는 run() 메소드에 배치되고, run 메소드에서의 호출은 순서대로 이루어지며, 모두 프로그램이 실행되는 순서대로 실행됩니다. 인스턴스 생성 방법: class=" list-paddingleft-2">
      • 🎜void Join() 다른 스레드를 실행하기 전에 스레드가 종료될 때까지 기다리세요🎜🎜
      • 🎜 void Join(long mils) 이 스레드의 대기 시간은 밀리초입니다. 이 시간이 지나면 다른 스레드는 🎜🎜rrreee🎜🎜
        • 🎜getPriority() 현재 스레드 우선순위 가져오기🎜🎜
        • 🎜setPriority(int num) 스레드 우선순위 변경(0- 10) 기본값은 5일수록 우선순위가 높을수록 CPU 자원을 얻을 확률이 높아집니다🎜🎜🎜🎜🎜use🎜🎜rrreee🎜🎜
          • 🎜setDaemon (boolean) 데몬 스레드로 설정되어 있는지, 데몬 스레드로 설정하면 메인 스레드가 소멸될 때 데몬 스레드도 함께 소멸됩니다🎜🎜
          • 🎜isDaemon() 데몬 스레드인지 확인하세요🎜🎜🎜🎜🎜use🎜🎜rrreee 🎜🎜🎜🎜

위 내용은 Thread의 정의와 일반적인 메소드의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!