java线程常用方法

Java线程常用方法

常用方法：

第一组

方法

1. setName //设置线程名称，使之与参数name相同

2. getName //返回该线程的名称

3. start //使该线程开始执行

4. run //调用线程对象run方法

5. setPriority // 更改线程优先级

6. getpriority //获取线程的优先级

7. sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

8. interrupt //中断线程

注意事项和细节

1. start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程

2. 线程优先级范围

3. interrupt，中断线程，并没有真正结束线程。所以一般用于中断正在休眠线程

4. sleep ：线程的静态方法，使当前线程休眠

案例

package threaduse;

public class ThreadMethod01 {
    public static void main(String[] args) {
        Car car=new Car();
        Thread thread0=new Thread(car);
        Thread thread1=new Thread(car);
        thread0.start();
        thread1.start();
        for(int i=0;i<5;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hi"+i);
        }
        thread0.interrupt();//中断线程休眠
        thread1.interrupt();//中断线程休眠
    }


}
class Car implements Runnable{
    private static int num=0;
    private int count=0;
    @Override
    public void run() {
        Thread.currentThread().setName("car"+(num++));//设置线程名字
        while(true){
            System.out.println(Thread.currentThread().getName()+"跑"+(++count));//得到线程名字
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==20){
                break;
            }
        }
    }
}

第二组

方法

1. yield：线程的礼让。让出cpu资源，让其他线程执行，但礼让的时间不确定，所以也不一定成功

2. join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务。

案例：

package threaduse;

public class ThreadMothed02 {
    public static void main(String[] args) throws InterruptedException {
        Hi h1=new Hi();
        h1.start();
        //说明：
        // 1.让h1插队到主线程前面，这样main就会等待h1执行完毕在执行
        // 2.如果没有join，那么会交替执行
        h1.join();
        for(int i=1;i<20;i++){
            Thread.sleep(50);
            System.out.println("张三丰"+i);
        }
    }
}
class Hi extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <20; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("JoinThread----"+i);

        }
    }
}

练习

题目

1.主线程每隔1s，输出hi，一共10次

2.当输出到hi 5时，启动一个子线程（要求实现Runnable），每隔1s输出hello，等该线程输出10 hello 后，退出

3.主线程继续输出 hi，知道线程退出。

4.完成代码，实现线程插队

代码

package threaduse;

public class ThreadMethodExpercise {
    public static void main(String[] args) throws InterruptedException {
        Hello hello=new Hello();
        Thread thread=new Thread(hello);
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi "+i);
            Thread.sleep(1000);
            if(i==5){
                thread.start();//注意此处不要写反。
                thread.join();//写反效果可以自己试一下。
            }
        }
    }
}
class Hello implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("hello "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

用户线程和守护线程

介绍

**1.**用户线程：也叫工作线程，当线程的任务执行完或通知方式结束

**2.**守护线程：一般时为工作线程服务的，当所有的用户线程结束。守护线程自动结束

**3.**常见的守护线程：垃圾回收机制

守护线程方法设置：

T.setDaemon(true);

举例：

package threaduse;

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        T t=new T();
        Thread thread=new Thread(t);
        thread.setDaemon(true);//设置为守护线程
        thread.start();
        for(int i=1;i<=10;i++){
            System.out.println("me too");
            Thread.sleep(1000);
            if(i==10){
                System.out.println("no");
            }
        }
    }
}
class T implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("i love you");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}