Java线程深入的理解

最新推荐文章于 2023-04-19 21:59:26 发布

hackerbaseing

最新推荐文章于 2023-04-19 21:59:26 发布

阅读量186

点赞数

分类专栏： runable 文章标签： Thread

本文链接：https://blog.csdn.net/hackerbaseing/article/details/89440583

版权

runable 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

今天来讲解下java的线程机制.废话不多说，直接上代码吧。线程实现之Runable接口，我们选择该接口比较好，实现资源的共享

/**
 * @author hackbase   Java多线程之Runable接口
 */
public class ThreadTestDemo2 {
    public static void main(String[] args) {
        HelloWorld h1=new HelloWorld("线程A");
        Thread  Demo=new Thread(h1);
        HelloWorld h2=new HelloWorld("线程B");
        Thread  Demo1=new Thread(h2);
        Demo.start();
        Demo1.start();
    }
}


class HelloWorld implements  Runnable{
    private  String name;
    /**
     * 添加无参数的构造方法
     */
    public HelloWorld(){

    }

    public HelloWorld(String name){
        this.name=name;

    }

    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println(name+"运行了    "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程的休眠调用的线程的Sleep方法,比如Thread.Sleep()来实现，谁调用，谁去睡觉。来看看下面的代码.

/**
 * @author hackbase   下面我们来看看线程的休眠----->>>
 * 线程的休眠调用线程的Sleep函数来实现，谁调用，谁去睡觉.
 */
public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleepone he = new ThreadSleepone();
        Thread demo = new Thread(he, "线程A");
        demo.start();

    }
}


class ThreadSleepone implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程的插入使用的join方法，比如目前2个线程，分别是A,B,当我们把b线程插入到A线程之后，此时A线程就会终止.等待B线程执行完毕之后，再去执行A线程。相当于A线程执行了一半，就回去执行B线程，当B线程执行完毕后，在继续执行A线程。

下面来看看代码把。

/**
 * @author hackbase   将一个线程强制插入到另外的一个线程里面.
 */
public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin he = new ThreadJoin();
        Thread Demo = new Thread(he, "线程A在运行.....");
        Demo.start();
        for (int j = 0; j < 50; j++) {
            if (j > 10) {
                try {
                    Demo.join();//强制的执行线程A
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main线程在执行---->>>>>>"+j);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}


class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

从程序的结果我们可以看到。

线程的中断使用的就是InTerrupt函数来实现的。下面我们来看看代码把

/**
 * @author hackbase  线程的中断使用interrupt函数来实现.
 */
public class ThreadInterrupt {
    public static void main(String[] args) {
        ThreadSlep he = new ThreadSlep();
        Thread demo = new Thread(he, "线程----->");
        demo.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       demo.interrupt();//1秒后线程被中断.
    }
}


class ThreadSlep implements Runnable {

    @Override
    public void run() {
        System.out.println("开始执行Run方法");
        try {
            //线程开始休眠
            Thread.sleep(Long.parseLong("1000"));
        } catch (InterruptedException e) {
            System.out.println("线程休眠突然被中断的时候被打断");
            return;
        }
        System.out.println("线程正常的终止------>");
    }
}

获得当前线程的名字使用的就是GetName方法来实现的，下面来看看代码。

/**
 * @author hackbase  取得线程的名字.
 * 每次java程序启动的时候，都会启动两个线程，一个是main方法，所运行的线程，一个就是垃圾回收器运行线程
 *
 */
public class ThreadDemoTest5 {
    public static void main(String[] args) {
        GetThreadName h1 = new GetThreadName();
        new Thread(h1, "A线程").start();
        new Thread(h1, "B线程").start();
        new Thread(h1, "C线程").start();

        new Thread(h1).start();
    }
}


class GetThreadName implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

代码很简单，就不多解释了。

为何使用runable,而不是使用Thread类来实现了，我们来看看代码把。

/**
 * @author hackbase   使用Runable接口更加的容易实现资源的共享.
 * 实现runbale接口的好处:
 * 1.适合多个相同的 程序代码去处理同一资源.
 * 2.增加代码的健壮性，代码可以被多个线程共享.让程序和数据独立.
 */
public class ThreadDemoTest4 {
    public static void main(String[] args) {
        MyThread my=new MyThread ();
        MyThread ts = new MyThread(my, "窗口1在售票");
        new Thread(my,"窗口1在售票").run();
        new Thread(my,"窗口2在售票").run();
        new Thread(my,"窗口3在售票").run();
    }
}


class MyThread implements Runnable {
    private int ticket = 5;

    public MyThread(){

    }

    public MyThread(MyThread ts, String name) {

    }

    @Override
    public void run() {
        for (int i = 0; i <= 20; i++) {
            if (this.ticket > 0) {
                System.out.println(Thread.currentThread().getName()+ "正在卖票= " +this.ticket--);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

/**
 * @author hackbase  关于是选择thread还是实现Runable接口了。
 * 来看看下面的代码。Runable更加的容易实现资源的共享.
 * 继承Thread不能实现资源的共享.
 */
public class ThreadDemoTest3 {
    public static void main(String[] args) {
        HelloTest h1=new HelloTest();
        HelloTest h2=new HelloTest();
        HelloTest h3=new HelloTest();
        h1.start();
        h2.start();
        h3.start();

    }
}


class  HelloTest extends Thread{
    private  int count=5;
    @Override
    public void run() {
        //重写了run方法
        for(int i=0;i<7;i++){
            if(count>0){
                System.out.println("count=  "+count--);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

使用 Runable接口来实现线程，更好，建议大家使用该接口来实现java的线程.

设置线程的优先级，一般优先级越高的线程首先会获得Cpu的使用权限，但是并不一定，还是来看看代码把.

/**
 * @author hackbase   设置线程的 优先级，可以通过SetPriority方法来实现了。
 * 来看看下面的代码.
 * 在一般情况下，优先级越高的线程就会先执行，但是并不一定，谁先执行取决于谁先获得Cpu的资源。
 * 线程的礼让，可以使用yield将线程交给其他的 线程来执行------>
 */
public class SetPriority {
    public static void main(String[] args) {
        Thread h1 = new Thread(new HelloWorldSetProicty(), "A");
        Thread h2 = new Thread(new HelloWorldSetProicty(), "B");
        Thread h3 = new Thread(new HelloWorldSetProicty(), "C");
        h1.setPriority(8);
        h2.setPriority(2);
        h3.setPriority(6);
        h1.start();
        h2.start();
        h3.start();
    }
}


class HelloWorldSetProicty implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " 在运行   " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

设置守护线程，来看看代码。使用SetDemo来实现的。来看看代码.

/**
 * @author hackbase   今天来说说java的守护线程.正如名字所言，守护线程。。
 * 在java里面只要前台有一个线程在运行，整个java程序就不会消失的。所以此时可以设置一个后台的线程.
 * 即使这样java线程消失了，那么后台的程序依旧可以运行，这就是守护线程，还是来看看下面的代码吧
 * 守护线程就是前台线程可以消失。，但是后台线程可以继续运行。
 * 虽然是一个死循环，但是还是可以执行完毕的。因为死循环的操作线程设置为守护线程了。
 */
public class SetDemoThread {
    public static void main(String[] args) {
        SetHello he = new SetHello();
        Thread h1 = new Thread(he, "线程");
        //设置守护线程.
        h1.setDaemon(true);
        h1.start();
        System.out.println("main线程执行完毕------>");
    }

}

class SetHello implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + "守护在运行----->");
        }
    }
}

判断线程是否启动

/**
 * @author hackbase   isAlive判断线程是否启动.....
 */
public class IsAliveDemo {
    public static void main(String[] args) {
        ActiveThread Demo1 = new ActiveThread();
        Thread he = new Thread(Demo1);
        System.out.println("线程在启动之前------>>>" + he.isAlive());
        he.start();
        System.out.println("线程在启动之后------>>>" + he.isAlive());
    }
}


class ActiveThread extends Thread {
    @Override
    public void run() {
        /**
         * 重写了run方法.
         */
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "正在运行......");
        }
    }
}

/**
 * @author hackbase Java的多线实现.
 */
public class DemoTest1 {
    public static void main(String[] args) {
        ThreadTest t1 = new ThreadTest("jack");
        ThreadTest t2 = new ThreadTest("bill");
        t1.start();
        t2.start();
    }
}

class ThreadTest extends Thread {
    private String name;

    public ThreadTest() {

    }

    public ThreadTest(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(name + "运行了" + i + "次");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

hackerbaseing

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java线程深入的理解

今天来讲解下java的线程机制.废话不多说，直接上代码吧。线程实现之Runable接口，我们选择该接口比较好，实现资源的共享/** * @author hackbase Java多线程之Runable接口 */public class ThreadTestDemo2 { public static void main(String[] args) { Hel...
复制链接

扫一扫

专栏目录