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-19 下一篇

发表评论

登录... 后才能评论