## Java多线程
### 进程和线程基本概念
### 进程--概念
进程是指运行中的应用程序，每个进程都有自己独立的地址空间(内存空间)，比如用户打开一个软件，这就相当于启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户打开另一个软件，相当于又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。
要点：用户每启动一个进程，操作系统就会为该进程分配一个独立的内存空间。
### 线程--概念
线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。
线程
1、线程是轻量级的进程
2、线程没有独立的地址空间(内存空间)
3、线程是由进程创建的(寄生在进程)
4、一个进程可以拥有多个线程-->这就是我们常说的多线程编程
5、线程有几种状态：
a、新建状态(new)
b、就绪状态(Runnable)
c、运行状态(Running)
d、阻塞状态(Blocked)
e、死亡状态(Dead)
### 线程的用处
解决了并发问题，也就是说当对象需要同时运行时，就可以用多线程技术。
### 线程--如何使用
在java中一个类要当作线程来使用有两种方法。
### 1、继承Thread类，并重写run函数
### 2、实现Runnable接口，并重写run函数
因为java是单继承的,在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能，java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程。
### 通过继承Thread类和实现Runnable接口来实现建立线程
~~~
/**
* 继承Thread类实现线程
* 或者实现Runnable接口
*/
package com.thread;
public class Thread1 {
public static void main(String[] args) {
// 创建对象
Cat cat = new Cat();
// 启动线程,调用run()方法
cat.start();
Dog dog = new Dog();
//创建线程
Thread t = new Thread(dog);
//启动线程
t.start();
}
}
class Cat extends Thread{
// 记数
int times = 0;
public void run() {
// 休眠一秒
// 1000毫秒 = 1秒
// sleep()进入Block状态，并释放资源
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
times++;
System.out.println("hello,world " + times);
if (times == 10) {
break;
}
}
}
}
// 创建Runnable接口
class Dog implements Runnable {
int times = 0;
// 重写run函数
public void run() {
// 休眠一秒
// 1000毫秒 = 1秒
// sleep()进入Block状态，并释放资源
while (true) {
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
times++;
System.out.println("hello,wrold!" + times);
if (times == 10) {
break;
}
}
}
}
~~~
~~~
/**
* 两个线程同时运行的案例
*/
package com.thread;
public class Thread2 {
public static void main(String[] args) {
Pig pig = new Pig(10);
Bird bird = new Bird(10);
//创建线程
Thread t1 = new Thread(pig);
Thread t2 = new Thread(bird);
//启动线程
t1.start();
t2.start();
}
}
//累加
class Bird implements Runnable{
int n = 0;
int times = 0;
int sum = 0;
public Bird(int n){
this.n = n;
}
public void run(){
while(true){
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
sum += (++times);
System.out.println("当前结果是：" + sum);
if(times == n){
System.out.println("最后结果是：" + sum);
break;
}
}
}
}
//打印
class Pig implements Runnable{
int n = 0;
int times = 0;
public Pig(int n){
this.n = n;
}
public void run(){
while(true){
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
times++;
System.out.println("线程输出 " + times);
if(times == n){
break;
}
}
}
}
~~~
### 线程--继承Thread 和实现Runnable的区别
从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口，如果一定要说它们有什么区别，有如下几点：
1、尽可能使用实现Runnable接口的方式来创建线程
2、在使用Thread的时候只需要new一个实例出来，调用start()方法即可以启动一个线程，如：
~~~
Thread test=new Thread();
test.start();
~~~
3、在使用Runnable的时候需要先new一个实现Runnable的实例，之后用Thread调用，如:
~~~
Test t=new Test();//Test实现了Runnable接口
Thread test=new Thread(t);
tset.start();
~~~
用实现Runnable接口的特点
1、用实现Runnable接口的方法创建对象可以避免java单继承机制带来的局限；
2、用实现Runnable接口的方法，可以实现多个线程共享同一段代码(数据)；
因此如果程序有同步逻辑需求，则使用Runnable的方法来创建线程。
### 线程--深入理解
不管是通过继承Thread，还是通过实现Runnable接口创建线程，它们的一个对象只能启动(即：start())一次。否则就会有异常抛出。
### java线程的同步
### 线程同步机制--介绍
多线程编程为我们处理同时并发的事务提供了很好的帮助，但是由此而来却引发一个严重的问题，那就是线程的安全问题。
而解决这个问题的关键，是保证事务的原子性(线程1开始执行某段原子代码，线程2要执行这段代码，必须等待线程1执行完成后，才能执行。)
Java中处理事务原子性的方法非常简单，只需要在需要保证原子性的代码块用如下代码:
~~~
synchronized(Object){
<span style="white-space:pre"> </span>代码块
}
~~~
这就是java线程的同步机制。
~~~
package com.thread;
public class Thread3 {
public static void main(String[] args) {
//定义售票窗口
TicketWindow tw1 = new TicketWindow();
//创建线程
Thread t1 = new Thread(tw1);
Thread t2 = new Thread(tw1);
Thread t3 = new Thread(tw1);
//启动线程
t1.start();
t2.start();
t3.start();
}
}
//售票窗口类
class TicketWindow implements Runnable {
//票数
private int nums = 2000;
@Override
public void run() {
while(true){
//同步代码块
synchronized (this) {
// 判断是否有票
if (nums > 0) {
// 显示售票信息，currentThread().getName()获取当前线程的名字
System.out.println(Thread.currentThread().getName() + "正在售出第" + nums + "票");
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
nums--;
} else {
// 票已卖完
break;
}
}
}
}
}
~~~
###
### 线程同步机制--深入理解
java任意类型的对象都有一个标志位，该标志位具有0、1两种状态，其开始状态为1，当某个线程执行了synchronized(Object)语句后，object对象的标志位变为0的状态，直到执行完整个synchronized语句中的代码块后，该对象的标志位又回到1状态。
当一个线程执行到synchronized(Object)语句的时候，先检查Object对象的标志位，如果为0状态，表明已经有另外的线程正在执行synchronized包括的代码，那么这个线程将暂时阻塞，让出CPU资源，直到另外的线程执行完相关的同步代码，并将Object对象的标志位变为1状态，这个线程的阻塞就被取消，线程能继续运行，该线程又将Object的标志位变为0状态，防止其它的线程再进入相关的同步代码块中。
如果有多个线程因等待同一个对象的标志位面而处于阻塞状态时，当该对象的标志位恢复到1状态时，只会有一个线程能够进入同步代码执行，其它的线程仍处于阻塞的状态。
----------参考《韩顺平.循序渐进学.java.从入门到精通》
----------参考《JDK_API_1_6_zh_CN》
Java学习笔记--导航[http://blog.csdn.net/q547550831/article/details/49819641](http://blog.csdn.net/q547550831/article/details/49819641)
