java线程系列---Runnable和Thread的区别、线程同步

Runnable和Thread的区别原文

线程锁原文

鉴于我这篇文章被鄙视了,哈哈哈哈。我决定整理一下资源共享线程同步相关的知识。欢迎鄙视并谈一谈见解。


Java传统多线程的实现有两种方法,继承Thread类或者实现Runnable


在这之前需要让大家从源码上了解一下Thread和runnable这两个类,Thread 也是实现自Runnable,在runnable接口里面有个run方法。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
那其实这个run其实就是为了多线程方面的一些扩展抽象出来的一个方法。


那我们就来看看Thread 对这个方法的实现做了什么。


 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
内容很简短明了。大概就是执行target的run方法,这个target也有一个run方法。这个target是什么?

全局搜索看一下,在声明中可以看到。

 /* What will be run. */
    private Runnable target;

说明这个target是一个runnable对象。而它正是从Thread的构造里面传进来的。

  public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

到这里大家可能就会明白为什么多个Thread对象传入同一个Runnable对象可以实现资源共享了。

因为runnable对象是同一个啊。


我们都知道线程启动是调用了Thread对象中的start方法;

可以看一下start方法到底做了什么

    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
这里面 的group是一个线程组对象ThreadGroup。start0()是一个原生方法,大概是调用jvm里面的方法了。started则是一个标志位。

说明它会把这个线程加到线程组中,这个线程组就是用来保存当前线程的一个容器,可以监测线程的生老病死,还有设置组内的优先级等,线程的执行则由start0这个原生的方法控制。


实现Runnable接口相比继承Thread类有如下好处:

1.避免单继承的局限,一个类可以同时实现多个接口

2.适合资源的共享.


接下来就写几个案例来说明资源共享和线程同步

class MyThread extends Thread {
    private int ticket = 5;

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            sale();
        }
    }

    //使用同步方法
    public void sale() {
        if (this.ticket > 0) {
            System.out.println(Thread.currentThread().getName()
                    + "卖票:1张 " + this.ticket--);
        }
    }

    public static void main(String[] args) {
//        MyThread mt = new MyThread();
        Thread thread1 = new MyThread("售票口一");
        Thread thread2 = new MyThread("售票口二");
        Thread thread3 = new MyThread("售票口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
执行结果如下:

售票口一卖票: 5
售票口一卖票: 4
售票口一卖票: 3
售票口一卖票: 2
售票口一卖票: 1
售票口三卖票: 5
售票口三卖票: 4
售票口三卖票: 3
售票口三卖票: 2
售票口三卖票: 1
售票口二卖票: 5
售票口二卖票: 4
售票口二卖票: 3
售票口二卖票: 2
售票口二卖票: 1


这边可以看出每个线程都有5张票。并没有资源共享。

class MyThread implements Runnable {
    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            sale();
        }
    }

    //使用同步方法
    public void sale() {
        if (this.ticket > 0) {
            System.out.println(Thread.currentThread().getName()
                    + "卖票: " + this.ticket--);
        }
    }

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread thread1 = new Thread(mt, "售票口一");
        Thread thread2 = new Thread(mt, "售票口二");
        Thread thread3 = new Thread(mt, "售票口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

输出结果:


售票口二卖票: 5
售票口二卖票: 3
售票口二卖票: 2
售票口二卖票: 1
售票口三卖票: 4
售票口一卖票: 5


终于资源共享了。哎哟卧槽,怎么两个售票口都卖了一次票5,仔细思考一下。是不是有可能两个线程是同时执行ticket--的。

好像有道理。这个时候就需要同步代码块上场了。我在操作票的时候就不准你们操作了等我操作完,你们再操作。


先科普一下线程同步


JAVA多线程同步主要依赖于若干方法和关键字
  1  wait方法

  2  notify方法和notifyAll方法

  3  synchronized关键字

  4 atomic action(原子操作)

此处针对上面情况使用同步关键字synchronized解决.同步关键字使用有2种方法

  1.同步代码块

  2.同步方法


同步代码块

使用synchronized关键字进行同步代码块的声明,但是在使用此操作时必须明确的指出到底要锁定的是哪个对象,一般是以当前对象为主.

  synchronized(对象){   //一般都是讲this锁定

         //锁定对象

     }

class MyThread implements Runnable {
    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized (this) {
                sale();
            }
        }
    }

    //使用同步方法
    public void sale() {
        if (this.ticket > 0) {
            try {
                Thread.sleep(200);    //休息200毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()
                    + "卖票: " + this.ticket--);
        }
    }

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread thread1 = new Thread(mt, "售票口一");
        Thread thread2 = new Thread(mt, "售票口二");
        Thread thread3 = new Thread(mt, "售票口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
输出如下


售票口一卖票: 5
售票口一卖票: 4
售票口一卖票: 3
售票口一卖票: 2
售票口二卖票: 1

总算正常了。不过加休眠是什么鬼,这个呃...因为不休眠线程全给一条线程跑完了。囧~~

你们可以试试休眠不加同步。这边会出很多访问的问题。


最后介绍同步方法


class MyThread implements Runnable {
    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
                sale();
        }
    }

    //使用同步方法
    public synchronized void sale() {
        if (this.ticket > 0) {
            try {
                Thread.sleep(100);    //休息200毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()
                    + "卖票: " + this.ticket--);
        }
    }

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread thread1 = new Thread(mt, "售票口一");
        Thread thread2 = new Thread(mt, "售票口二");
        Thread thread3 = new Thread(mt, "售票口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

输出如下:


售票口一卖票: 5
售票口一卖票: 4
售票口一卖票: 3
售票口二卖票: 2
售票口二卖票: 1


最后因为加上了线程锁,很容易出现线程阻塞,死锁等问题。


产生死锁的必要条件和如何预防死锁


有问题欢迎探讨!!



            
阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/guoxiaolongonly/article/details/50717574
文章标签: 线程 Thread Runnbale
个人分类: JAVA学习
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭