- 线程的基本概念和优劣之处
- 创建一个线程的两种方式
- 线程的属性
- 线程的状态
- synchronized可修饰的方法
- synchronized的重要特性
一、线程的基本概念
在计算机中有进程和线程这么两个概念，进程中可以有多个线程，它们是从属关系，进程往往更像是资源的占有者，线程才是程序的执行者，多个线程之间共享着进程中的资源。一个cpu同时只能运行一个线程，每个线程都有一个时间片，时间片用完了就会被阻塞并让出CPU的控制权，交给下一个线程使用。这样在计算机中就可以实现多任务的假象，其实CPU在不断的切换线程，好像多个任务在同时运行。
使用线程的优势毋庸置疑，可以增加CPU的执行效率，一旦某个线程需要等待某种资源（例如：等待打印机），就可以将它阻塞释放CPU让CPU执行别的线程，而不需要让CPU和此线程一起等待某种资源从而提高系统效率，另外一点就是可以用这种假象增加用户体验度。但是，CPU在切换不同线程之间所要花费的代价也是不可忽视的，在较为复杂的程序中这种劣势可能九流一毛，但是如果在简单的程序中就会显得尤为突出。
二、创建一个线程
接下来我们看看如何在java中创建一个线程来实现多个线程同时运行。第一种方式，java 中有一个类Thread，我们只要继承这个类并重写他的run方法，调用start方法就可以启动一个新的线程了。（没见过的同学可能不能理解以下代码，下面我会解释）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
/*声明自己的一个线程类*/
public class Test_thread extends Thread {
//重写Thread类中的run方法
public void run(){
System.out.println("i am the thread");
}
}
public class Test_Class {
public static void main(String[] args){
Test_thread thread = new Test_thread();
thread.start();
}
}
|
输出结果：i am the thread
首先我们先了解一下，一个线程被创建之后，怎么才能启动运行，我们调用thread.start();方法启动一个线程，首先就会执行我们重写的run方法（如果没有重写就会调用Thread类的run方法，什么也不做，这也是我们重写run方法的原因），也就是说run方法是一个线程的开始。有个疑问，为什么调用start方法，却执行了run方法了？其实调用start方法就是为线程的启动做准备操作，分配线程私有的堆栈资源，然后执行run方法。
下面我们看创建一个线程的第二种方式，实现接口Runnable，并重写其中的run方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class Test_thread implements Runnable {
public void run(){
System.out.println("i am the thread");
}
}
public class Test_Class {
public static void main(String[] args){
Test_thread thread = new Test_thread();
thread.start();//编译错误
}
}
|
我们会发现虽然重写了run方法，但是在调用start方法的时候却编译错误，我们进入到Runnable接口的源代码中可以看到，只有一个抽象方法run，所以没有启动线程的start方法，所以我们还是要借助Tread类。
|
1
2
3
4
5
6
|
public class Test_Class {
public static void main(String[] args){
Thread thread = new Thread(new Test_thread());
thread.start();
}
}
|
因为Thread类中有start方法，所以可以使用Thread的一个构造函数传入一个实现了Runnable接口的类型，构建一个Thread类。
三、线程的属性和状态
在一个多线程的程序中我们使用线程的一些属性来区别和辨认它们：
|
1
2
3
4
5
6
|
private long tid;
private volatile char name[];
public static native Thread currentThread()
private boolean daemon = false;
private volatile int threadStatus = 0;
public final static int NORM_PRIORITY = 5;
|
每个线程会有一个tid指定此线程的在所有线程中的排序，这个值是递增的，还有一个name指定该线程的名字，也可以使用setName设置一个优雅的线程名字，Thread类还提供了一个方法返回当前正在占用CPU的线程对象。每个线程在某个时刻都是有状态的，属性threadStatus记录了当前对象线程的状态是什么，默认情况下，所有的线程的优先级都被置为5，如果有特殊需要可以修改线程的优先级，使得某个线程可以优先得到运行。下面介绍线程的几种不同的状态。
- New:线程刚刚被创建，还没有被启动。
- Runnable：线程处于可运行的状态，但是不一定处于正在运行的状态（后面解释区别）
- Blocked:线程处于被阻塞的状态，一般是请求某资源不成功于是让出CPU阻塞自己（具体的区别后面说）
- Waiting：线程处于等待状态，一般是等待服务
- Terminated：线程终止，也就是线程被kill，释放其占用的资源
下面具体的说说不同状态下的线程的一些操作，首先看看new，线程从此被创建，只是离运行状态还需要一些准备。Runnable表示线程是可运行，至于是否已经处于运行状态还要看系统给的时间片是否用完，如果用完了就会将此线程放置在可运行线程队列的尾部，等待下次分配时间片，如果时间片没有用完，就是处于运行状态的（这也是为什么叫做Runnable而不是Running的原因）。接下来的两种状态Blocked和waiting都表示线程阻塞，需要让出CPU。只是导致它们处于这种状态的原因不一样，具体的在我们介绍完synchronized关键字之后就会不言而喻了。
四、关键字synchronized
先看一段代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
public class Test_thread extends Thread{
public static int count = 0;
public void run(){
try {
Thread.sleep((int) (Math.random() * 100));
}catch(InterruptedException e){
}
count++;
}
}
public class Test_Class {
public static void main(String[] args){
Test_thread[] thread = new Test_thread[1000];
for(int a=0;a<1000;a++){
thread[a] = new Test_thread();
thread[a].start();
}
for(int a=0;a<1000;a++){
try {
thread[a].join();
}catch (InterruptedException e){
}
}
System.out.println(Test_thread.count);
}
}
|
按照直觉，创建1000个线程，每个线程随机睡觉并将公共变量增一，main线程等待所有线程执行结束之后，输出公共变量的值。按照直觉答案应该是1000，但是我们运行的结果每次都是不一样的，接近1000但每次都不一样。这是为什么呢？这其实就是简单的模拟了高并发，可能有几个线程睡了相同的时间，同时醒来获取的count值是相同的，这就导致这几个线程对count的操作被覆盖了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class Test_thread extends Thread{
public static int count = 0;
public void run(){
try {
Thread.sleep((int) (Math.random() * 100));
}catch(InterruptedException e){
}
/*使用关键字*/
synchronized (Test_thread.class){
count++;
}
}
}
|
一个简单的关键字就可以轻松解决这样的高并发的问题。至于为什么这么写？在介绍完synchronized关键字之后，想必你就会知道了。
首先我们需要知道，每个对象都有一把内部锁。所以被synchronized关键字修饰的方法，其实是被加了内部对象锁。我们看代码：
|
1
2
3
4
5
6
7
8
|
public class Counter{
private int count;
/*为实例方法加此关键字*/
public synchronized int getCount(){
return count;
}
}
|
为实例方法添加关键字，实际上就是给当前的对象加锁；括号中就是要加锁的对象。
|
1
2
3
4
5
6
7
8
|
public class Counter{
private int count;
/*为实例方法加此关键字*/
synchronized(this){
return count;
}
}
|
对于静态方法，实际上就是为这个类加上锁；
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class Counter{
private static int count;
public static synchronized int getCount(){
return count;
}
}
/*实际上给这个类加上锁*/
public class Counter{
private int count;
synchronized(Counter.class){
return count;
}
}
|
五、深入理解synchronized的一些特性
第一个性质是：可重入性。被synchronized修饰的方法中的所有操作都是原子操作，但是当我们需要在其中访问另外的一些需要锁的代码时候，可以直接获取别的锁。也就是当前的对象是可以获得多个锁的。
第二个性质是：内存的可见性。在我们的计算机中，其实有很多的操作并不是很"干脆"的，比如你向数据库中存数据时，其实很多时候一些待存入的数据积累在缓存中等到一定数据量的时候才会统一的存入数据库，但是在我们看来这些数据其实应该早就存入数据库了。这就导致了一个内存的不可见性问题。当然我们也是可以使用关键字synchronized来保证每次取出的数据都是最新的。在释放锁的时候会立即将数据协会内存，获得锁的时候会去读取最新的内容。
|
1
2
3
4
5
6
7
8
|
public class Counter{
private int count;
public synchronized int getCount(){
return count;
}
}
/*每次获得该对象的锁之后，去获取最新的count数值*/
|
其实，如果仅仅是要保证内存的不可见性，使用synchronized关键字可能代价有点高，在这种情况下，我们可以使用关键字volatile。
|
1
2
3
4
5
6
7
8
9
|
public class Counter{
/*使用关键字volatile*/
private volatile int count;
public int getCount(){
return count;
}
}
/*此关键字保证每次使用count的时候数据都是最新的*/
|
总结
以上就是这篇文章的全部内容了，还是希望大家发现其中错误直接指出，方便我纠正错误，更新知识。java并发系列文章，希望大家多多关注。
原文链接：http://www.cnblogs.com/yangming1996/p/6515830.html