java多线程学习笔记

进程:正在执行的程序,是一个动态的过程

线程:是进程中用于控制程序执行的控制单元(执行路径,执行情景)

进程中至少有一个线程。

在Java VM(java虚拟机)启动的时候会有一个进程java.exe.

该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。

扩展:其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回收机制的线程。

创建线程

创建线程的第一种方式:继承Thread类

步骤:

1,定义类继承Thread。
2,复写Thread类中的run方法。
    目的:将自定义代码存储在run方法。让线程运行。

3,调用线程的start方法,
    该方法两个作用:启动线程,调用run方法。

发现运行结果每一次都不同。因为多个线程都获取cpu的执行权。cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序在运行(多核除外)。cpu在做着快速的切换,以达到看上去是同时运行的效果。

我们可以形象把多线程的运行形容为在互相抢夺cpu的执行权。

这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说的算。

为什么要覆盖run方法呢?

Thread类用于描述线程。该类就定义了一个功能,用于存储其他线程(非主线程)要运行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法,用于存储线程要运行的代码。

创建线程的第二种方式:实现Runable接口

步骤:

1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法。
    将线程要运行的代码存放在该run方法中。

3,通过Thread类建立线程对象。
4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
    为什么要将Runnable接口的子类对象传递给Thread的构造函数。
    因为,自定义的run方法所属的对象是Runnable接口的子类对象。
    所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。


5,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

两种创建现场的区别

实现方式和继承方式有什么区别呢?

实现方式好处:避免了单继承的局限性。
在定义线程时,建立使用实现方式。

两种方式区别:

继承Thread:线程代码存放Thread子类run方法中。

实现Runnable,线程代码存在接口的子类的run方法。

线程中的方法

线程都有自己默认的名称:Thread-编号 该编号从0开始。

线程中的常用方法

static Thread currentThread():获取当前线程对象。
getName(): 获取线程名称。

设置线程名称:setName或者构造函数。

多线程中出现的问题

多线程的运行出现了安全问题。

问题的原因:

当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,
另一个线程参与进来执行。导致共享数据的错误。

解决办法:

对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式。

就是同步代码块,方法如下

synchronized(对象)//任意对象都行
{
    需要被同步的代码

}

对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。

同步的前提:

1,必须要有两个或者两个以上的线程。
2,必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处:解决了多线程的安全问题。

弊端:多个线程都需要判断锁,较为消耗资源,

示例代码如下:

public class TicketDemo2 {

    public static void main(String[] args) {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }

}

class Ticket implements Runnable {
    private int tick = 100;
    Object obj = new Object();// 为synchronized提供对象

    public void run() {
        while (true) {
            synchronized (obj) {
                if (tick > 0) {
                     try{Thread.sleep(50);}catch(Exception e){}
                    System.out.println(Thread.currentThread().getName() + "....sale : " + tick--);
                }
            }
        }
    }
}

此段代码的是模拟卖票,假设有100张票,然后有4个线程同时卖票。
可以在Ticket类中有synchronized同步代码块,当有同步代码块时,持有synchronized同步锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取synchronized同步锁。线程将依序执行,也就是有一个线程在进入时,另一个线程无法进入。

如果没有synchronized同步锁,那么有可能会有以下问题产生,当tick剩下1张票的时候,t1现场进入了,然后遇到Thread.sleep(50),失去执行权。

接着t2线程执行了了,此时tick仍然是1张票,因此t2也进入if语句,也遇到sleep()方法,失去了执行权。

然后t3线程也来了,遇到了与t1/t2一样的状况。

t4线程也既有可能遇到这种情况。

最后t1开始执行了,tick为0了。但是此时t2也在if语句中,也执行语句,tick就为-1,然后是t3/t4,导致了代码运行的结果出现了负数,与设想中的不同!

上面所描述的问题就是多线程中所要解决的问题,这也是synchronized同步锁的使用情景

同步锁

synchronized可以给代码块上锁,也可以给方法上锁,如下:

        // 同步代码块
        synchronized (对象) {
            ····· 代码块
        }
        
        // 同步方法
        public synchronized void show (){}

那么问题来了,在同步代码块中我们可以很清楚的看到synchronized给哪一个对象上锁,那么同步方法又是给谁上锁呢?

同步函数用的是哪一个锁呢?
函数需要被对象调用。那么函数都有一个所属对象引用,就是this,所以同步函数使用的锁是this。

通过该程序进行验证。

使用两个线程来买票。一个线程在同步代码块中。一个线程在同步函数中。都在执行买票动作。

代码如下:

public class TicketDemo2 {

    public static void main(String[] args) {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        // 让主线程休眠,将执行权移交给t1/t2线程
        try{Thread.sleep(10);}catch(Exception e){}
        t.flag = false;
        t2.start();

    }

}

class Ticket implements Runnable {
    private int tick = 100;
    Object obj = new Object();
    // 使用flag
    boolean flag = true;

    public void run() {
        if (flag) {
            while (true) {
                // 使用的锁是obj
                synchronized (obj) {
                    if (tick > 0) {
                        try{Thread.sleep(10);}catch(Exception e){}
                        System.out.println(Thread.currentThread().getName() + "....code : " + tick--);
                    }
                }
            }
        } else
            while (true)
                show();
    }
    // 同步方法的锁对象是this,即所属对象的引用
    public synchronized void show()    {  
        if (tick > 0) {
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName() + "....show.... : " + tick--);
        }
    }
}

上述代码中添加了同步方法,并且设置了flag布尔值,用以让线程能在中途从同步代码块中切换到同步方法中。

然后再控制台中看到结果:

Thread-1....show.... : 4
Thread-0....code : 3
Thread-1....show.... : 2
Thread-1....show.... : 1
Thread-0....code : 0

这里居然卖出了0张票,这明显是一个错误的结果,这是为什么呢?

答案在于我们虽然在多线程中使用了同步锁,但是我们的锁对象并不是同一个对象,因为在同步代码块中使用的是obj对象,如下:

synchronized (obj) {
·····代码省略
}

但是当obj替换成this的时候,我们就能输出正确的结果,不在输出0张票。

这足以证明在同步方法中使用的锁对象就是所属对象引用。

静态同步方法

static实际上也能使用同步锁,我们将上述代码修改,首先将同步方法修改为静态同步方法,然后将tick也标识为static,代码如下:

private static  int tick = 100;
···

public static synchronized void show(){
····
}

调用方法跟前面一样。

这时再次输出了tick=0的错误结果!

这又是为什么呢?

这是因为静态方法中的同步锁对象使用的不是this,因为静态方法中也不可以定义this。

其原因在于静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
即 类名.class 该对象的类型是Class

静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class。

所以我们将同步代码块中的所对象修改为Ticket.class时就能输出正确结果,此时Ticket完整代码如下:

class Ticket implements Runnable {
    private static  int tick = 100;
    Object obj = new Object();
    boolean flag = true;

    public void run() {
        if (flag) {
            while (true) {
                synchronized (Ticket.class) {
                    if (tick > 0) {
                        try{Thread.sleep(50);}catch(Exception e){}
                        System.out.println(Thread.currentThread().getName() + "....code : " + tick--);
                    }
                }
            }
        } else
            while (true)
                show();
    }
    // 静态方法的所对象是    类名.class
    public static synchronized void show()    {  
        if (tick > 0) {
            try{Thread.sleep(50);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName() + "....show.... : " + tick--);
        }
    }
}

单例模式中的懒汉式

单例模式中的懒汉式写法其实颇为复杂,因为要考虑到多线程的问题。如果不添加synchronized进行同步,在多线程的情况下,仍有可能导致创建了多个单例的实例,这就违背了单例模式的设计出初衷,因此必须添加synchronized进行同步,正确写法如下:

class Single {
    private static Single s = null;

    private Single() {
    }

    public static Single getInstance() {
        if (s == null) {
            synchronized (Single.class) {
                if (s == null)
                    s = new Single();
            }
        }
        return s;
    }
}

懒汉式与饿汉式的区别在于懒汉式用于延时加载。

而懒汉式出现的问题在于使用多线程的时候创建多个实例,这时可以使用同步解决。

使用synchronized同步也是有技巧的,如果使用同步方法也是可以的,代码如下:

    public synchronized static Single getInstance() {
        if (s == null) {                
                if (s == null)
                    s = new Single();
            }            
        return s;
    }

但这种写法会导致效率稍微低下,因此一般都采用双重判断的同步代码块的写法。

同时如果是使用了static静态符合,静态代码块所使用的同步锁为该类所属的字节码对象!

死锁

产生死锁的四个必要条件:

(1) 互斥条件:一个资源每次只能被一个进程使用。
(2) 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
(3) 不剥夺条件:进程已获得的资源,在末使用完之前,不能强行剥夺。
(4) 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

同步中嵌套同步,但是它们之间的锁却不同,容易导致死锁,下面是死锁示例:

public DeadLockTest TicketDemo2 {

    public static void main(String[] args) {
        Thread t1 = new Thread(new Test(true));
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
    }

}

class Test implements Runnable {
    private boolean flag;

    Test(boolean flag) {
        this.flag = flag;
    }

    public void run() {
        if (flag) {
            while (true) {
                synchronized (MyLock.locka) {
                    System.out.println(Thread.currentThread().getName() + "...if locka ");
                    synchronized (MyLock.lockb) {
                        System.out.println(Thread.currentThread().getName() + "..if lockb");
                    }
                }
            }
        } else {
            while (true) {
                synchronized (MyLock.lockb) {
                    System.out.println(Thread.currentThread().getName() + "..else lockb");
                    synchronized (MyLock.locka) {
                        System.out.println(Thread.currentThread().getName() + ".....else locka");
                    }
                }
            }
        }
    }
}

class MyLock {
    static Object locka = new Object();
    static Object lockb = new Object();
}

在上面的例子中Test在t1线程中进入if语句得到了MyLock.locka的锁,然后进入了第二个代码块中需要MyLock.lockb的锁才能进行下一步。

但是此时t2线程也开始执行了,它先进入了Test中的else语句,获得了MyLock.locka的锁,需要MyLock.locka的所完成同步代码。

此时陷入了死局,t1持有了MyLock.locka的锁,但是无法获得MyLock.lockb的锁执行完线程,也无法释放MyLock.locka的锁。

而t2线程同样如此,持有MyLock.lockb的锁,但是无法获得MyLock.locka的锁执行完线程,也无法释放MyLock.locka的锁。

在写程序的时候应该避免死锁的产生。

线程间通信

线程间通讯: 其实就是多个线程在操作同一个资源,但是操作的动作不同。

wait:
notify();
notifyAll();

notify()方法用于唤醒等待中的线程,一般线程使用了wait()方法,会进入线程池中等待执行,此时使用notify()方法一般唤醒线程池中的第一个等待线程。

都使用在同步中,因为要对持有监视器(锁)的线程操作。
所以要使用在同步中,因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作线程所持有的锁,
只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。

也就是说,等待和唤醒必须是同一个锁。

而锁可以是任意对象,所以可以被任意对象调用的方法定义Object类中。

多线程生产消费者示例

下列代码为正确示例:

class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r = new Resource();

        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

/*
 * 对于多个生产者和消费者。 为什么要定义while判断标记。 原因:让被唤醒的线程再一次判断标记。
 * 为什么定义notifyAll, 因为需要唤醒对方线程。 因为只用notify,容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
 */

class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;

    // t1 t2
    public synchronized void set(String name) {
        while (flag)
            try {this.wait();} catch (Exception e) {} // t1(放弃资格) t2(获取资格)
        this.name = name + "--" + count++;

        System.out.println(Thread.currentThread().getName() + "...生产者.." + this.name);
        flag = true;
        this.notifyAll();
    }

    // t3 t4
    public synchronized void out() {
        while (!flag)
            try { wait();} catch (Exception e) {} // t3(放弃资格) t4(放弃资格)
        System.out.println(Thread.currentThread().getName() + "...消费者........." + this.name);
        flag = false;
        this.notifyAll();
    }
}

class Producer implements Runnable {
    private Resource res;

    Producer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.set("+商品+");
        }
    }
}

class Consumer implements Runnable {
    private Resource res;

    Consumer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            res.out();
        }
    }
}

在多线程的情况下,通用的做法是使用while循环 + notifyAll()唤醒方法来判断执行代码。

而在单生产者和单消费者的情况下使用if循环 + notify()来判断执行代码。

首先分析一下使用if循环 + notify()在多生产者和多消费者中产生的问题,使用这种方法会导致程序执行两次生产,一次消费的情况,又或者是两次消费一次生产的情况。

关键代码如下:

public synchronized void set(String name)
{
    if(flag)
        try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
    this.name = name+"--"+count++;

    System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    flag = true;
    this.notify();
}

//  t3   t4  
public synchronized void out()
{
    if(!flag)
        try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
    System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
    flag = false;
    this.notify();
}

产生这种情况的原因在于如果生产者(t1/t2)先获得了执行权,此时flag为false,因此t1直接往下执行,生产出一个产品(执行println),然后将flag设为true,但是此时t1仍然能继续执行(本案例中线程没有退出机制,因此一旦执行将持续执行不停止),于是t1再次在if语句中判断,然而flag已经为true,所以t1执行了wait()方法,放弃执行权。

重点来了,在这个时候t2生产者,t3/t4消费者都有执行权,假设这时t2取得执行权,执行下去了,此时flag仍为true,因此t2也进如wait()阶段。

然后就轮到t3/t4执行了,他们消费一次之后,将flag设为false,然后唤醒了在线程池中的线程,而notify()会唤醒处于线程池中的第一个等待的线程,也就是t1。然而此时t3仍旧执行,但是遇到flag为false,于是t3执行了wait()方法。

这时线程中拥有执行权的就剩下生产者t1和消费者t4了,然而计算机执行了t4线程,因为flag为false的缘故,t4也等待了。

此时在线程池中等待的顺序依次为 t2,t3,t4。

t1开始执行了,然后把flag设置为true,并且执行了notify()方法,唤醒了t2线程。

但是之前t2已经通过了if的判断,处于wait()状态,因此被唤醒的时候不在执行if判断,直接往下执行,因此在t1之后也执行了生产命令。

最后唤醒了t3消费者,然后继续执行。

这就是联系两次执行了生产命令的原因。

上面说的有点啰嗦,但这非常重要,需要细细体会。

了解了为什么在多生产/消费者执行的情况下,使用if判断和notify()方法唤醒会持续执行两次生产或者消费的命令后,这是因为if只判断一次flag的情况,当线程被唤醒之后会直接往下执行的缘故。

那么我们如果使用while加上notify()方法,让线程每次被唤醒的时候都进行判断呢?

这时产生了死锁。

这个结束比较简单,首先t1运行,flag为true,然后t1继续执行的时候就进入wait()方法,如果此时t2执行的话,也进入wait()方法中。

然后t3/t4执行了,t3将flag设为false,并唤醒了t1,然后t3继续执行便执行了wait()方法,如果此时t4执行了,也会进入wait()方法中,这时消费者线程全灭

最后剩下t1在执行了,t1将flag设置true之后,唤醒了t2,但是此时flag为true,而每次唤醒都会在while进行一次循环,此时悲催的t2再次进入wait()方法,生产者线程也全灭了!

因为只用notify,容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

这就是产生死锁的原因。

所以在多生产多消费者的情况下使用while让每个线程在唤醒的时候再次进行判断,然后使用notifyAll()唤醒所有的线程,让每个线程再次做判断是否继续往下执行,这样才能确保每次都有线程能够执行,也能确保每个线程都能被唤醒,不会导致死锁。

使用jdk1.5之后的Lock接口进行同步

上面生产者和消费者的使用方法太过繁琐了,JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait,notify notifyAll,替换了Condition对象。该对象可以Lock锁 进行获取。
在下列示例中,实现了本方只唤醒对方操作。

Lock:替代了Synchronized
    lock 
    unlock
    newCondition()

Condition:替代了Object wait notify notifyAll
    await();
    signal();
    signalAll();

我们修改上面生产者和消费者案例中的Resource的代码,将Synchronized替换为Lock,将notifyAll替换为Condition,代码如下:

class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;
    // t1 t2
    private Lock lock = new ReentrantLock();

    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();

    public void set(String name) throws InterruptedException {
        lock.lock();
        try {
            while (flag)
                condition_pro.await();// t1,t2等待
            this.name = name + "--" + count++;

            System.out.println(Thread.currentThread().getName() + "...生产者.." + this.name);
            flag = true;
            condition_con.signal(); // 唤醒t3,t4中的一个
        } finally {
            lock.unlock();// 释放锁的动作一定要执行。
        }
    }

    // t3 t4
    public void out() throws InterruptedException {
        lock.lock();
        try {
            while (!flag)
                condition_con.await();
            System.out.println(Thread.currentThread().getName() + "...消费者........." + this.name);
            flag = false;
            condition_pro.signal();
        } finally {
            lock.unlock();
        }

    }
}

class Producer implements Runnable {
    private Resource res;

    Producer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            try {
                res.set("+商品+");
            } catch (InterruptedException e) {
            }

        }
    }
}

class Consumer implements Runnable {
    private Resource res;

    Consumer(Resource res) {
        this.res = res;
    }

    public void run() {
        while (true) {
            try {
                res.out();
            } catch (InterruptedException e) {
            }
        }
    }
}

使用Condition的好处在于一个Lock锁可以拥有多个Condition对象。

而在上面的代码中定义了两个Condition对象,一个为生产者condition_pro的条件,另一个为消费者condition_con条件。

这使condition_pro可以使用自己的await()方法和condition_pro.signal()唤醒方法,这样就能让在生产者中唤醒消费者,而在消费者中唤醒生产者,不会发生像Synchornized中的那种唤醒了本方线程的失误事件。

但是要注意,使用Lock的时候,一定要在finally中释放锁,即调用lock.unlock()方法。

停止线程的方式

stop方法已经过时。

如何停止线程?
只有一种,run方法结束。
开启多线程运行,运行代码通常是循环结构。

只要控制住循环,就可以让run方法结束,也就是线程结束。

示例代码中给Runnable对象添加了flag标记,控制了while循环,代码如下:

class StopThreadDemo {
    public static void main(String[] args) {
        StopThread st = new StopThread();
        
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);

        t1.start();
        t2.start();

        int num = 0;

        while (true) {
            if (num++ == 60) {    
                st.changeFlag();
                t1.interrupt();
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName() + "......." + num);
        }
        System.out.println("over");

    }
}

class StopThread implements Runnable {
    private boolean flag = true;
    
    public void run() {
        while (flag) {    
            System.out.println(Thread.currentThread().getName() + "....run");
        }
    }

    public void changeFlag() {
        flag = false;
    }
}

特殊情况:
当线程处于了冻结状态。
就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态是,这时需要对冻结进行清除。
强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。Thread类提供该方法 interrupt();

示例如下:

class StopThread implements Runnable {
    private boolean flag = true;
    
    public synchronized void run() {
        while (flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "....Exception");
                flag = false;
            }
            System.out.println(Thread.currentThread().getName() + "....run");
        }
    }

    public void changeFlag() {
        flag = false;
    }
}

class StopThreadDemo {
    public static void main(String[] args) {
        StopThread st = new StopThread();
        
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);

        t1.start();
        t2.start();

        int num = 0;

        while (true) {
            if (num++ == 60) {                    
                t1.interrupt();
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName() + "......." + num);
        }
        System.out.println("over");

    }
}

要注意的是使用 interrupt();方法并不是正确的停止线程的方式,而是以抛出异常的方式停止线程,要慎用。

Thread中的其他方法

setDaemon(boolean on) 将该线程标记为守护线程或用户线程。简单的说就是将线程设置为后台线程,此时将会与主线程抢夺CPU资源,而且主线程结束时,后台线程会自动结束。

修改上面的StopThreadDemo代码,将t1/t2线程设置为后台线程,如下

class StopThreadDemo {
    public static void main(String[] args) {
        StopThread st = new StopThread();
        
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);

        t1.setDaemon(true);
        t2.setDaemon(true);
        t1.start();
        t2.start();

        int num = 0;

        while (true) {
            if (num++ == 60) {                    
                
                break;
            }
            System.out.println(Thread.currentThread().getName() + "......." + num);
        }
        System.out.println("over");

    }
}

class StopThread implements Runnable {
    private boolean flag = true;
    
    public void run() {
        while (flag) {    
            System.out.println(Thread.currentThread().getName() + "....run");
        }
    }

    public void changeFlag() {
        flag = false;
    }
}

此时并没有使用任何的方式结束线程,却发现当主线程结束时,t1/t2线程也结束了。

join()方法与yield()方法

join:
当A线程执行到了B线程的.join()方法时,A就会等待。等B线程都执行完,A才会执行。

join可以用来临时加入线程执行,代码示例:

class JoinDemo {
    public static void main(String[] args) {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();

         try {
            t1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        t2.start();

        for (int x = 0; x < 80; x++) {
             System.out.println("main....."+x);
        }
        System.out.println("over");
    }
}

class Demo implements Runnable {
    public void run() {
        for (int x = 0; x < 70; x++) {
            System.out.println(Thread.currentThread().toString() + "....." + x);
        }
    }
}

toString():返回该线程的字符串你表示形式,包括线程名称、优先级和线程组

yield():暂停当前正在执行的线程对象,并执行其他线程,代码示例:

class YieldDemo {
    public static void main(String[] args) {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();


        t2.start();

        System.out.println("over");
    }
}

class Demo implements Runnable {
    public void run() {
        for (int x = 0; x < 70; x++) {
            System.out.println(Thread.currentThread().toString() + "....." + x);
            Thread.yield();
        }
    }
}

线程间通讯

Java线程间通讯其实也就是使用Synchronized和Object类方法wait(),notify(),notifyAll()的共同使用,保证运行结果正确,这些都在上述代码有所涉及。

你可能感兴趣的:(java多线程学习笔记)