Java实现多线程

鳄鱼君

发表文章数:642

热门标签

, ,

Vieu四代商业主题

高扩展、安全、稳定、响应式布局多功能模板。

¥69 现在购买
首页 » Java » Java实现多线程

java支持多线程机制,并且java已经将多线程实现了,我们只需要继承就可以了。第一种方式:编写一个类,直接继承java.lang.Thread,重写run方法:

public class ThreadTest {
    // main方法,主线程,在主栈中运行
    public static void main(String[] args) {
        // 创建线程对象
        MyThread thread1 = new MyThread();
        // thread1.run();// 不会启动线程,不会自动分配新的分支栈(单线程)
        
        // 启动线程
        // 任务只是为了开启一个新的栈空间,只要新的栈空间开出来,start方法就结束了,线程就启动成功了
        // 启动一个分支线程,在JVM中开辟一个新的栈空间,这段代码任务完成之后,瞬间就结束了
        // 启动成功的线程会自动调用run方法,并且run方法在分支栈的底部(压栈)
        // thread1.start();
        // 以下代码运行在主线程中
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程---->" + i);
        }
    }
}

class MyThread extends Thread{
    public void run(){
        // 编写程序,这段程序运行在分支线程中
        for (int i = 0; i < 10; i++) {
            System.out.println("分支线程---->" + i);

        }
    }
}

第二种方式:编写一个类实现java.lang.Runnable接口:

public class ThreadTest {
    // main方法,主线程,在主栈中运行
    public static void main(String[] args) {

        // 创建一个可运行的对象
        MyThread thread1 = new MyThread();
        // 将可运行的对象封装成一个线程
        Thread t = new Thread(thread1);
        // 启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程---->" + i);
        }

    }
}
// 这并不是一个线程类,是一个可运行的类,还不是一个线程
class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("分支线程---->" + i);

        }
    }
}

第二种方式实现接口比较常用,因为一个类实现了接口,它还可以继承其它的类,更灵活!

public class ThreadTest {
    // main方法,主线程,在主栈中运行
    public static void main(String[] args) {

        // 将可运行的对象封装成一个线程
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("分支线程---->" + i);
                }
            }
        });
        // 启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程---->" + i);
        }

    }
}

获取线程的名字、当前线程对象:

public class ThreadTest {
    // main方法,主线程,在主栈中运行
    public static void main(String[] args) {

        // currentThread就是当前线程对象
        // 出现在main方法中,所以当前线程对象就是main
        Thread curr = Thread.currentThread();
        System.out.println(curr.getName());//main

        // 将可运行的对象封装成一个线程
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    // 获取当前线程对象
                    Thread curr = Thread.currentThread();
                    System.out.println( curr.getName() + "---->" + i);
                }
            }
        });
        // 设置线程的名字
        // t.setName("鳄鱼君");
        // 获取线程的名字
        System.out.println(t.getName());// 默认Thread-0
        // 启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程---->" + i);
        }

    }
}

关于线程sleep方法:

  1. 静态方法:Thread.sleep(1000)
  2. 参数是毫秒
  3. 当前线程进入休眠,进入“阻塞状态”,放弃占有CPU时间片,让给其它线程使用,例如使用在A线程,A线程就会进入休眠
public class ThreadTest {
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程---->" + i);
            // 睡眠1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

终断睡眠:

public class ThreadTest {
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread());
        t.setName("t");
        t.start();

        // 希望5s之后,t线程性来
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终断t线程的睡眠
        // 依靠java的异常处理机制
        t.interrupt();


    }
}
class MyThread implements Runnable{
    public void run(){
        System.out.println(Thread.currentThread().getName() + "---->begin");
        try {
            Thread.sleep(1000*60*60*24*365);
        } catch (InterruptedException e) {
            // 打印异常信息
            System.out.println(e.getMessage());
        }
        System.out.println("1年之后才会执行的方法");
    }
}

合理的终止线程的执行:

public class ThreadTest {
    public static void main(String[] args) {
        MyThread r = new MyThread();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();

        // 希望5s之后,t线程结束
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程
        r.run = false;


    }
}
class MyThread implements Runnable{
    boolean run = true;

    public void run(){
        for (int i = 0; i < 10; i++) {
            if (run){
                System.out.println(Thread.currentThread().getName() + "---->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                return;
            }

        }
    }
}

常见的线程调度模型:
抢占式调度模型:哪个线程的优先级比较高,抢到的CPU时间片的概率就高一些,java就是采用的这种调度模式
均分式调度模型:平均分配CPU时间,每个线程占有的CPU时间片时间长度一样,平均分配,一切平等
线程的优先级:

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("最高优先级:" + Thread.MAX_PRIORITY);//10
        System.out.println("最低优先级:" + Thread.MIN_PRIORITY);//1
        System.out.println("默认优先级:" + Thread.NORM_PRIORITY);//5

        // 获取当前线程对象,的优先级
        Thread curr = Thread.currentThread();
        System.out.println("线程的默认优先级:" + curr.getPriority());//5
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        // 设置主线程的优先级为1
        Thread.currentThread().setPriority(1);

        Thread t = new Thread(new MyThread());
        //
        t.setPriority(10);
        t.setName("t");
        t.start();
        // 优先级较高的,只是抢到的CPU时间片相对较多
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);

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

线程让位,当前线程暂停,回到就绪状态,让给其它线程:

public class ThreadTest {
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread());
        t.setName("t");
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}
class MyThread implements Runnable{
    public void run(){
        for (int i = 0; i < 100; i++) {
            // 每50个让一次位
            if (i==10){
                Thread.yield();// 当前线程暂停,让给主线程
            }
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

线程合并:

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main begin");
        Thread t = new Thread(new MyThread());
        t.setName("t");
        t.start();
        // t合并到当前线程,当前线程受阻塞
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main over");
    }
}
class MyThread implements Runnable{
    public void run(){
        for (int i = 0; i < 10; i++) {
            // 每50个让一次位
            if (i==10){
                Thread.yield();// 当前线程暂停,让给主线程
            }
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

未经允许不得转载:作者:鳄鱼君, 转载或复制请以 超链接形式 并注明出处 鳄鱼君
原文地址:《Java实现多线程》 发布于2020-08-18

分享到:
赞(0) 赏杯咖啡

评论 抢沙发

6 + 9 =


文章对你有帮助可赏作者一杯咖啡

支付宝扫一扫打赏

微信扫一扫打赏

Vieu4.6主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。
切换注册

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录
切换登录

注册