java并发编程-多线程技能

1.1 进程和多线程的概念

1.2 使用多线程

1.2.1 继承Thread类

Thread类的结构 public class Thread implements Runnable
Thread实现了Runnable接口，使用继承Thread创建新的线程时，局限在于不支持多继承
代码：

public class T extends Thread {

    @Override
    public void run() {
        super.run();
        System.out.println("run...");
    }

    public static void main(String[] args) {
        T t = new T();
        t.start();
        System.out.println("执行结束");
    }
}

执行结果：

执行结束
run...

从执行结果可以看出run方法中执行的时间比main方法中System.out.println("执行结束");要晚，这里说明在使用多线程时，代码的运行结果与代码的调用顺序无关
注：线程是一个子任务，cpu以随机的时间来调用run方法

start()与run() :
t.start()方法通知“线程规划器”，线程已经准备好了，等待调用run()方法，具有异步执行的效果,而调用t.run()方法则是由main主线程调用run()方法，是同步的，也就是必须等run()方法执行晚才能执行后面的代码

注:执行start()方法的顺序不等于线程启动的顺序 代码如下

public class T extends Thread {

    @Override
    public void run() {
        super.run();
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        T t = new T();t.setName("1");
        T t2 = new T();t2.setName("2");
        T t3 = new T();t3.setName("3");
        T t4 = new T();t4.setName("4");
        t.start();
        t2.start();
        t3.start();
        t4.start();
        System.out.println("执行结束");
    }
}

执行结果：

1
3
执行结束
2
4

1.2.2 实现runnable接口

代码：

public class R implements Runnable {

    @Override
    public void run() {
        System.out.println("run...");
    }

    public static void main(String[] args) {
        R r = new R();
        Thread thread = new Thread(r);
        thread.start();
        System.out.println("执行结束...");
    }
}

执行结果：

执行结束...
run...

1.2.3 实例变量与线程安全

实例变量针对其它线程来说有共享和不共享的区别，这个是线程交互之间很重要的一点

1.2.3.1 不共享数据

代码：

public class T extends Thread {

   private int count = 10;

    @Override
    public void run() {
        super.run();
        while (count > 0) {
            count--;
            System.out.println(Thread.currentThread().getName() + "--->" + count);
        }

    }

    public static void main(String[] args) {
        T t = new T();
        t.setName("A");
        T t2 = new T();
        t2.setName("B");
        T t3 = new T();
        t3.setName("C");

        t.start();
        t2.start();
        t3.start();
        System.out.println("执行结束");
    }
}

结果：

A--->9
A--->8
A--->7
A--->6
A--->5
A--->4
A--->3
A--->2
A--->1
A--->0
B--->9
B--->8
执行结束
B--->7
B--->6
C--->9
C--->8
C--->7
C--->6
C--->5
C--->4
C--->3
C--->2
B--->5
B--->4
B--->3
B--->2
B--->1
B--->0
C--->1
C--->0

一共创建了3个线程，每个线程都有自己的变量count，这种情况数据不共享，不存在多个线程访问同一个实例变量的情况

1.2.3.2 共享数据

代码：

public class T extends Thread {

    private int count = 10;

    @Override
    public void run() {
        super.run();
        count--;
        System.out.println(Thread.currentThread().getName() + "--->" + count);
    }

    public static void main(String[] args) {
        T thread = new T();
        Thread t = new Thread(thread, "A");
        Thread t2 = new Thread(thread, "B");
        Thread t3 = new Thread(thread, "C");
        Thread t4 = new Thread(thread, "D");
        Thread t5 = new Thread(thread, "E");
        t.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        System.out.println("执行结束");
    }
}

结果：

A--->8
C--->7
B--->8
D--->6
执行结束
E--->5

注： A、B线程打印的都是8，说明A和B同时在对count处理，产生了非线程安全的问题，
由于count–在jvm的处理要拆分成以下3步：
取得原count值–>计算count-1–>将计算结果赋值给count
在这三个步骤中，如果有多个线程同时访问，将出现线程安全问题

通过在run方法前加入synchronized 关键字可以使得多个线程排队执行run方法
synchronized 可以在任意对象及方法上加锁，加锁的这段代码成为 互斥区 或者 临界区

public class T extends Thread {

    private int count = 10;

    @Override
    synchronized public void run() {
        super.run();
        count--;
        System.out.println(Thread.currentThread().getName() + "--->" + count);


    }

    public static void main(String[] args) {
        T thread = new T();
        Thread t = new Thread(thread, "A");
        Thread t2 = new Thread(thread, "B");
        Thread t3 = new Thread(thread, "C");
        Thread t4 = new Thread(thread, "D");
        Thread t5 = new Thread(thread, "E");
        t.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        System.out.println("执行结束");
    }
}

当一个线程想要执行例子中的同步方法的代码时，先尝试去拿这把锁，当拿到这把锁的时候，其他线程就拿不到锁，而且可能会有多个线程同时去争夺这把锁，当synchronized锁的对象中的代码执行完，会释放锁。