Java多线程

创建线程的方式
比较常见的一个问题了，一般就是两种：
（1）继承Thread类
（2）实现Runnable接口
至于哪个好，不用说肯定是后者好，因为实现接口的方式比继承类的方式更灵活，也能减少程序之间的耦合度，面向接口编程也是设计模式6大原则的核心。

1、继承Thread类：
　　　　步骤：①、定义类继承Thread；
　　　　　②、复写Thread类中的run方法；
　　　　目的：将自定义代码存储在run方法，让线程运行
　　　　　③、调用线程的start方法：
　　　　该方法有两步：启动线程，调用run方法。
public static void main(String[] args) {
		//创建线程
		Thread mt = new Thread();
		Thread mt2 = new Thread();
		//修改线程名字void SetName(String name)
		mt.setName("小明");
		执行多线程特有方法，如果使用td.run();也会执行，但会以单线程方式执行。
		mt.start();
		mt2.start();
}
//继承Thread类
public class thread extends Thread{
	 //重写run方法。
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(get.Name());//getName（） 获取线程名称。
		}
	}
	
}

2、实现Runnable接口： 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。

 　　　　实现步骤：  ①、定义类实现Runnable接口

　　　　　　　　　　②、覆盖Runnable接口中的run方法

　　　　　　　　　　　　　将线程要运行的代码放在该run方法中。

　　　　　　　　　　③、通过Thread类建立线程对象。

　　　　　　　　　　④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

　　　　　　　　　　　　　自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确run方法所属对象

　　　　　　　　　　⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

public static void main(String[] args) {
		//创建线程
		Thread mt = new Thread();
		Thread mt2 = new Thread(mt);
		//修改线程名字void SetName(String name)
		mt2.setName("小明");
		//启动线程
		
		mt2.start();
}


public class thread implements Runnable{
	//static Thread currentThread();返回当前线程对象
	@Override
	public void run() {
		for (int i = 0; i <100; i++) {
			System.out.println(Thread.currentThread().getName() + i);
		}
		
	}
}

 

火车票案例
public static void main(String[] args) {
		//创建线程
		Thread mt = new Thread();
		Thread mt2 = new Thread(mt);//多个窗口共享总票数
		Thread mt3 = new Thread(mt);
		Thread mt4 = new Thread(mt);
		//修改线程名字void SetName(String name)
		mt2.setName("窗口一");
		mt3.setName("窗口二");
		mt4.setName("窗口三");
		//启动线程
		
		mt2.start();
		mt3.start();
		mt4.start();
}

public class thread implements Runnable{
	int ticket = 100;//火车票数量
	@Override
	public void run() {
		while(true) {//火车站永远开门
			if(ticket>0) {
				System.out.println(Thread.currentThread().getName() + ticket--);
			}
		}
	}
}

三种方法对比：

　　　　继承Thread：线程代码存放在Thread子类run方法中。

　　　　　　　　优势：编写简单，可直接用this.getname（）获取当前线程，不必使用Thread.currentThread（）方法。

　　　　　　　　劣势：已经继承了Thread类，无法再继承其他类。

　　　　实现Runnable：线程代码存放在接口的子类的run方法中。

　　　　　　　　优势：避免了单继承的局限性、多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。

　　　　　　　　劣势：比较复杂、访问线程必须使用Thread.currentThread（）方法、无返回值。

　　　　实现Callable：

　　　　　　　　优势：有返回值、避免了单继承的局限性、多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。

　　　　　　　　劣势：比较复杂、访问线程必须使用Thread.currentThread（）方法

建议使用实现接口的方式创建多线程。

线程睡眠---sleep：

　　　　线程睡眠的原因：线程执行的太快，或需要强制执行到下一个线程。

　　　　线程睡眠的方法（两个）：Thread.sleep（long millis）在指定的毫秒数内让正在执行的线程休眠。

　　　　　　　　　　　　　　　　Thread.sleep（long millis，int nanos）在指定的毫秒数加指定的纳秒数内让正在执行的线程休眠。

 

1.为什么要使用synchronized  
在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。

2.实现原理  
synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性

3.synchronized的三种应用方式  
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：  
1. 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁 
2. 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁 
3. 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 
4.synchronized的作用  
Synchronized是Java中解决并发问题的一种最常用最简单的方法 ，他可以： 
（1）确保线程互斥的访问同步代码 
（2）保证共享变量的修改能够及时可见 
（3）有效解决重排序问题
当两个线程同时对一个对象的一个方法进行操作，只有一个线程能够抢到锁。因为一个对象只有一把锁，一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，就不能访问该对象的其他synchronized实例方法，但是可以访问非synchronized修饰的方法

public synchronized void method1() {

非静态同步方法锁对象是this，静态的同步方法锁对象是当前类的字节码对象

1.线程的生命周期
线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

(1)生命周期的五种状态

新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。
例如：Thread  t1=new Thread();

就绪（runnable）
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();

运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

死亡（dead）
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

自然终止：正常运行run()方法后终止

异常终止：调用stop()方法让一个线程终止运行

堵塞（blocked）
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。

正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

正在等待：调用wait()方法。（调用motify()方法回到就绪状态）

被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

Waiting(无时间限制的等待状态)：这个状态下也是不能分配CPU执行的。有三种情况会使得Runnable状态到waiting状态

调用无参的Object.wait()方法。等到notifyAll()或者notify()唤醒就会回到Runnable状态。调用无参的Thread.join()方法。也就是比如你在主线程里面建立了一个线程A，调用A.join()，那么你的主线程是得等A执行完了才会继续执行，这是你的主线程就是等待状态。调用LockSupport.park()方法。LockSupport是Java6引入的一个工具类Java并发包中的锁都是基于它实现的，再调用LocakSupport.unpark(Thread thread)，就会回到Runnable状态。