进程和线程
进程
资源分配的最小单位。
线程
程序执行的最小单位
进程和线程的关系
同步和异步
同步：对于方法调用，必须等当前的方法执行完，才能进行后续方法的调用
异步：多个方法在不同的线程中同时执行，互相并不妨碍。
并行和并发
它们都表示在同一时间范围内有两个或者多个任务同时执行,但是在任务调度上是有区别的。
并发任务执行过程：
并行任务执行过程：
并发是两个任务在执行时，没有时间上的重叠，两个任务是交替执行的。
并行是两个任务有时间上的重叠，并行才是真正意义上的同一时刻有多个任务执行。
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线程课的学习总结笔记。
