Java 基础查漏补缺【多线程机制篇】

概念

线程：是一个程序内部的顺序控制流。通俗的来说，是一个程序里面不同的执行路径 （记住这句话就可以了）

程序： wechat.exe

进程： wechat.exe启动后，叫做一个进程，是相对于程序来说的，是个动态的概念

线程： 作为一个进程里面最小的执行单元就叫一个线程，或者说，一个程序里不同的执行路径就叫做一个线程

平时所讲的进程开始执行了，是指进程中的主线程（main方法）开始执行了

Java的线程是通过Java.lang.Thread来实现的
VM启动时会有一个由主方法(public static void main(){})所sing以的线程
可以通过创建Thread类的实例来创建新的线程
每个线程都是通过某个特定的Thread对象所对应的run()来完成其操作的，方法run()称为线程体。
通过调用Thread类的start方法来启动一个线程

线程的创建和启动

定义线程类实现Runnable接口

public class Runner1 implements Runnable{
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see Thread#run()
     */
    @Override
    public void run() {
        
    }
  
      public static void main(String[] args) {
        Runner1 runner1 = new Runner1();
        //runner1.run();  //方法调用，不是线程启动
        Thread t = new Thread(runner1);  
        t.start();  //	线程启动
    }
}

继承Thread类

public class Thread1 extends Thread {
    @Override
    public void run() {
        super.run();
    }

    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        thread1.start();
    }
}

线程的状态

线程同步

package com.shifpeng.scaffold.test;

public class TestSync implements Runnable {
    Timer timer = new Timer();

    public static void main(String[] args) {
        TestSync testSync = new TestSync();
        Thread th1 = new Thread(testSync);
        Thread th2 = new Thread(testSync);
        th1.setName("t1");
        th2.setName("t2");
        th1.start();
        th2.start();
    }

    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see Thread#run()
     */
    @Override
    public void run() {
        timer.add(Thread.currentThread().getName());
    }
}


class Timer {
    private static int num = 0;

    public void add(String name) {
        num++;
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf(name + "你是第" + num + "个使用Timer的线程\n");
    }
}

打印结果

1 2	t1你是第2个使用Timer的线程 t2你是第2个使用Timer的线程

这个小程序执行出来的效果明显不对，原因就是线程在执行过程中，被另外一个线程打断了，两个线程应该作为原子性的输出

如何解决？在执行当前过程中，锁住该线程：

锁定当前对象`synchronized(this)`

在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性，保证在一个时刻，只能有一个线程访问该对象

对上面的小程序做相应修改

class Timer {
    private static int num = 0;

    public void add(String name) {
        synchronized (this) {   //加入锁定机制
            num++;
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.printf(name + "你是第" + num + "个使用Timer的线程\n");
        }
    }
}
//t1你是第1个使用Timer的线程
//t2你是第2个使用Timer的线程

另一种简便的写法

class Timer {
    private static int num = 0;

    public synchronized void add(String name) {  //在执行当前方法的时候锁定当前对象
        num++;
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf(name + "你是第" + num + "个使用Timer的线程\n");
    }
}
//t1你是第1个使用Timer的线程
//t2你是第2个使用Timer的线程

死锁

package com.shifpeng.scaffold.test;

public class TestDeadLock implements Runnable {
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();

    @Override
    public void run() {
        System.out.printf("flag=" + flag + "\n");
        if (flag == 1) {
            synchronized (o1) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    System.out.printf("1" + "\n");
                }
            }
        }
        if (flag == 0) {
            synchronized (o2) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    System.out.println("0" + "\n");
                }
            }
        }
    }

    public static void main(String[] args) {
        TestDeadLock testDeadLock1 = new TestDeadLock();
        TestDeadLock testDeadLock2 = new TestDeadLock();
        testDeadLock1.flag = 1;
        testDeadLock1.flag = 0;
        Thread th1 = new Thread(testDeadLock1);
        Thread th2 = new Thread(testDeadLock2);
        th1.start();
        th2.start();
    }
}

程序执行到下面这里，就卡住不动了 
//flag=0
//flag=1

面试题 ：下面的程序中，m1在执行过程中，m2可以执行吗？

package com.shifpeng.scaffold.test;

public class TT implements Runnable {
    int b = 100;

    //synchronized 保证同一时间该方法只能允许一个线程访问
    public synchronized void m1() throws Exception {
        b = 1000;
        System.out.printf("b=" + b + "\n");
        Thread.sleep(5000);
        System.out.printf("b=" + b + "\n");
    }

    //这里不加synchronized，非同步方法。其他线程可以自由的访问非同步的方法，并且可能会对同步的方法产生影响
    public void m2() throws Exception {
        Thread.sleep(2500);
        b = 2000;
    }

    @Override
    public void run() {
        try {
            m1();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        TT tt = new TT();
        Thread th1 = new Thread(tt);
        th1.start();
        Thread.sleep(1000);
        tt.m2(); 
        System.out.println(tt.b);
    }
}

//打印结果

b=1000
2000
b=2000

//必须把访问这个资源（b）的所有的方法都要考虑到，每个方法是否都要设置成同步的，都要考虑到，加了同步，可能会导致效率变低，不加同步，可能会产生数据不一致的现象

上面得出的结论即：

一个对象中的非同步方法，可以被其他线程自由访问，并且可能对同步的方法产生影响

上面的程序加以修改（给m2也加上锁）

  //m1在锁定的过程中，m2也想锁定这个对象的另外一个方法，这个时候智能等到m1的锁释放后，才能获得锁，所以执行的结果如下
public synchronized void  m2() throws Exception {
        Thread.sleep(2500);
        b = 2000;
    }

//执行结果

b=1000
b=1000
2000

生产者消费者问题

package com.shifpeng.scaffold.test;

public class ProducerConsumer {
    public static void main(String[] args) {
        SyncStack syncStack = new SyncStack();
        Producer producer = new Producer(syncStack);
        Consumer consumer = new Consumer(syncStack);
        new Thread(producer).start();
        new Thread(consumer).start();
    }

}

class ManTou {
    int id;

    ManTou(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "馒头：" + this.id;
    }
}

/**
 * 篮子
 */
class SyncStack {
    int index = 0;
    ManTou[] manTous = new ManTou[6];

    /**
     * 存馒头
     *
     * @param mt
     */
    public synchronized void push(ManTou mt) {
        if (index == manTous.length) {
            try {
                this.wait();  //Object的方法  线程wait   注意：wait的时候，锁就不归我所有了
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();  //叫醒一个正在这个对象是wait的线程
        manTous[index] = mt;
        index++;
    }

    /**
     * 取馒头
     *
     * @return
     */
    public synchronized ManTou pop() {
        if (index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        index--;
        return manTous[index];
    }
}

/**
 * 生产者
 */
class Producer implements Runnable {

    SyncStack syncStack = null;

    Producer(SyncStack ss) {
        this.syncStack = ss;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            ManTou mt = new ManTou(i);
            syncStack.push(mt);
            System.out.println("生产了：" + mt);
            try {
                Thread.sleep((long)Math.random()*2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable {

    SyncStack syncStack = null;

    Consumer(SyncStack ss) {
        this.syncStack = ss;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            ManTou mt = syncStack.pop();
            System.out.println("消费了：" + mt);
            try {
                Thread.sleep((long)Math.random()*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

注意：上面的程序有个潜在性的问题

public synchronized void push(ManTou mt) {
    if (index == manTous.length) {
        try {
            this.wait();  //Object的方法  线程wait   注意：wait的时候，锁就不归我所有了
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    this.notify();  //叫醒一个正在这个对象是wait的线程
    manTous[index] = mt;
    index++;
}

上面的this.wait(); 如果被打断，就会进入到Exception，然后程序会继续执行，继续++，这个时候需要注意，程序需要做一些调整

/**
 * 存馒头
 *
 * @param mt
 */
public synchronized void push(ManTou mt) {
    while (index == manTous.length) {
        try {
            this.wait();  //Object的方法  线程wait   注意：wait的时候，锁就不归我所有了
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    this.notify();  //叫醒一个正在这个对象是wait的线程
    manTous[index] = mt;
    index++;
}

/**
 * 取馒头
 *
 * @return
 */
public synchronized ManTou pop() {
    while (index == 0) {
        try {
            this.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    this.notify();
    index--;
    return manTous[index];
}

需要将if 换成while

`wait` 和`sleep`的区别

wait是object的方法，sleep是thread的方法

wait时别的线程可以访问锁定对象
调用wait方法的时候必须锁定该对象
sleep时别的线程不可以访问锁定对象

如果您喜欢此博客或发现它对您有用，则欢迎对此发表评论。也欢迎您共享此博客，以便更多人可以参与。如果博客中使用的图像侵犯了您的版权，请与作者联系以将其删除。谢谢！

概念

线程的创建和启动

线程的状态

线程同步

锁定当前对象`synchronized(this)`

死锁

`wait` 和`sleep`的区别

特色标签

链友

概念

线程的创建和启动

线程的状态

线程同步

锁定当前对象synchronized(this)

死锁

wait 和sleep的区别

特色标签

链友

锁定当前对象`synchronized(this)`

`wait` 和`sleep`的区别