进程和线程

进程

资源分配的最小单位。

线程

程序执行的最小单位

进程和线程的关系

image.png

同步和异步

同步：对于方法调用，必须等当前的方法执行完，才能进行后续方法的调用
异步：多个方法在不同的线程中同时执行，互相并不妨碍。

并行和并发

它们都表示在同一时间范围内有两个或者多个任务同时执行,但是在任务调度上是有区别的。

并发任务执行过程：

image.png

并行任务执行过程：

image.png

并发是两个任务在执行时，没有时间上的重叠，两个任务是交替执行的。
并行是两个任务有时间上的重叠，并行才是真正意义上的同一时刻有多个任务执行。

Java实现多线程的方式

一：继承自Thread类

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

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

}

二：实现Runnable接口

public class RunnableTest implements Runnable{

    public void run() {
        System.out.println("RunnableTest");
    };
    
    
    public static void main(String[] args) {
        
        new Thread(new RunnableTest()).start();
    }

}

线程安全

线程安全的概念：当多个线程访问同一个对象或者方法时，这个对象始终能表吸纳出正确的行为，那么这个对象就是线程安全的。
线程安全就是在多线程访问时，采用加锁机制，当一个线程在访问某各类的数据，将这个类锁住，其他类无法访问，只有将锁释放后，其它类才能访问，来保证数据的正确性。

Synchronized 修饰符

Synchronized：可以子啊任意对象和方法上加锁，加锁的代码成为互斥区或者临界区

线程不安全的实例

public class ThreadTest2 extends Thread {
    int i = 5;

    @Override
    public void run() {
        i--;
        System.out.println(this.currentThread().getName() + "run():" + i);
    }

    public static void main(String[] args) {
        //多个线程操作同一个对象
        ThreadTest2 myThread = new ThreadTest2(); 
        Thread thread1 = new Thread(myThread);
        Thread thread2 = new Thread(myThread);
        Thread thread3 = new Thread(myThread);
        Thread thread4 = new Thread(myThread);
        Thread thread5 = new Thread(myThread);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }

}

输出结果

Thread-2run():2
Thread-3run():2
Thread-4run():1
Thread-5run():0
Thread-1run():2

使用Synchronized修饰符后

将run()方法加上修饰符

@Override
    public synchronized void run() {
        i--;
        System.out.println(this.currentThread().getName() + "run():" + i);
    }

输出结果

Thread-1run():4
Thread-5run():3
Thread-4run():2
Thread-3run():1
Thread-2run():0

使用synchronized修饰符，解决了线程安全的问题。

一个对象有一把锁，多个线程多个锁

public class ThreadTest2 extends Thread {
    int i = 5;

    @Override
    public synchronized void run() {
        i--;
        System.out.println(this.currentThread().getName() + "--- run():" + i);
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadTest2 myThreadTest1 = new ThreadTest2();
        Thread thread1 = new Thread(myThreadTest1);
        Thread thread2 = new Thread(myThreadTest1);
        Thread thread3 = new Thread(myThreadTest1);
        thread1.start();
        thread2.start();
        thread3.start();
        Thread.sleep(2000);
        ThreadTest2 myThreadTest2 = new ThreadTest2();
        Thread thread11 = new Thread(myThreadTest2);
        Thread thread22 = new Thread(myThreadTest2);
        Thread thread33 = new Thread(myThreadTest2);
        thread11.start();
        thread22.start();
        thread33.start();
    }

}

输出结果
Thread-1 --- run():4
Thread-3 --- run():3
Thread-2 --- run():2
Thread-5 --- run():4
Thread-7 --- run():3
Thread-6 --- run():2

上面代码中有两个对象 myThreadTest1和 myThreadTest2 如果它们使用的是同一个锁的话，运行结果就是是2的基础上继续往下减，由此可见，每个对象所拥有的自己的锁。

关键字synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁。

本文是http://gitbook.cn/gitchat/column/5a24fb14e3a13b7fc5933a44 gitChat线程课的学习总结笔记。