Java多线程编程
一、创建线程的方法一：
继承：extends Thread 重写run()方法
举个栗子🌰：
public class MyThread extends Thread {
public MyThread() {
//空的构造方法
}
//传递name表示线程名字
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (interrupted()) {
System.out.println("释放资源！");
break;
}
System.out.println(getName()+":"+i);
}
}
}
MyThread t1 = new MyThread(“线程一”);
MyThread t2 = new MyThread(“线程二”);
Thread thread = new Thread();
thread.start();//启动线程
thread.getPriority();//获取优先级
thread.setPriority();//设置优先级（1-10）
thread .getName();//获取线程名字
thread .setName();//设置线程名字
线程休眠：
Thread.sleep(4000);//主线程休眠四秒之后再运行
线程加入：
t1.join();//将线程t1加入主线程
设置守护线程：
t2.setDaemon(true);将t2线程设置为守护线程（守护线程需要在线程启动之前设置），守护线程是为守护其他线程而存在，如果其他所有线程都运行完之后，只还剩下守护线程没运行完，那么守护线程将自动销毁！
线程的中断：
t1.interrupt();//手动处理线程中断
interrupted();//将返回布尔值
线程的生命周期：
二、创建线程的方法二：
实现Runnable接口： implement Runnable
public class RunnableThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
Thread thread = Thread.currentThread();//获取当前线程名字
System.out.println(thread.getName()+":"+i);
}
}
}
该方法不能直接使用start()方法启动线程。 需要使用Thread声明一个对象，再将runnable对象传入Thread对象。
RunnableThread t = new RunnableThread();
Thread t1 = new Thread(t,”线程一”);
t1.start();
Thread t2 = new Thread(t,”线程二”);
t2.start();
两种创建线程方法区别： runnable方法只需要创建一个runnable对象，Thread方法需要创建多个MyThread对象。Thread方法获取线程其他参数更方便。两种方法都需要重写run()方法。
使用Runnable方法创建线程的好处：
- 可以很方便的实现多线程数据的共享。
- 该方法还可以继承其他的类，而继承Thread类的方法不能再继承其他的类了。
三、创建线程的方法三：
匿名内部类：
直接在主类里面定义一个Runnable类来实现Runnable接口里面的run()方法。
适用于该线程在主类里面只使用一次的情况，不用再创建一个线程类来实现Runnable接口。
线程安全问题：
当多个线程需要同时修改同一共享数据时，产生冲突，就会出现线程安全问题。
- 加锁解决:
private Object lock = new Object();//需要声明一个对象作为锁
//加锁
synchronized (lock) {
//需要加锁执行的代码
}//执行完毕，归还钥匙
也可以直接使用同步方法：sellTicket()
public synchronized void sellTicket(){
//需要加锁的代码
}//相当于给这个方法加了锁
同步方法不需要再声明一个对象作为锁了。
- 使用专门的锁对象ReentrantLock来加锁：
private ReentrantLock lock = new ReentrantLock();
lock.lock();//加锁
//需要加锁的代码
lock.unlock();//解锁
死锁问题的解决：
多个线程以相同的顺序去取锁，取到所有锁之后才执行需要加锁的代码！
举个栗子🌰：
public class DeadLock {
//创建两把锁
public static Object lock1 = new Object();
public static Object lock2 = new Object();
public static void main(String[] args) {
//启动两个线程
new Thread(new Thread1()).start();
new Thread(new Thread2()).start();
}
}
//匿名内部类实现Runnable创建Thread1线程
class Thread1 implements Runnable{
@Override
public void run() {
synchronized (DeadLock.lock1) {//先取第一把锁
System.out.println("Thread1取得了第一把锁之后要做的事情");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (DeadLock.lock2) {//再取第二把锁
System.out.println("Thread1同时取得两把锁之后要做的事情");
}
}
}
}
//匿名内部类实现Runnable创建Thread2线程
class Thread2 implements Runnable{
@Override
public void run() {
synchronized (DeadLock.lock1) {//先取第一把锁
System.out.println("Thread2取得了第二把锁之后要做的事情");
synchronized (DeadLock.lock2) {//再取第二把锁
System.out.println("Thread2同时取得两把锁之后要做的事情");
}
}
}
}
创建线程组：ThreadGroup
ThreadGroup tg = new ThreadGroup(“我的线程组”);
定时器：Timer
需要在计时器任务里面设置任务：TimerTask
Timer timer = new Timer();//定时器
timer.schedule(new MyTimer(), 2000);//2s后启动计时器任务
timer.schedule(new MyTimer(), 2000, 1000);//2s启动后，隔3s后再重复执行计时器任务
timer.cancel();//取消定时器
举个栗子🌰：
public class Demo_Timer {
public static void main(String[] args) {
Timer timer = new Timer();//定时器
//timer.schedule(new MyTimer(), 2000);
timer.schedule(new MyTimer(), 2000, 1000);
//timer.cancel();//取消定时器
}
}
//定时器任务（匿名内部类）
class MyTimer extends TimerTask{
@Override
public void run() {
System.out.println("定时器任务..");
}
}
四、综合实例：
电影院售票问题： 说明：两种买票方式，手机APP端和电影院窗口端同时售票，采用创建多线程的方式来解决电影票多端售出产生的冲突！
采用实现Runnable接口的方法创建线程。
1、创建AppThread类：（APP端线程类）
public class AppThread implements Runnable {
private Object lock;
public AppThread(Object lock) {
this.lock = lock;
}
@Override
public void run() {
while (MovieTicketManage.count>0) {
synchronized (lock) {
if (MovieTicketManage.count>0) {
System.out.println(Thread.currentThread().getName()+"售出了第"+MovieTicketManage.count+"张电影票..");
MovieTicketManage.count--;
}
}
try {
Thread.sleep(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
2、创建WindowThread类：（window端线程类）
public class WindowThread implements Runnable {
private Object lock;
public WindowThread(Object lock) {
this.lock = lock;
}
@Override
public void run() {
while (MovieTicketManage.count>0) {
synchronized (lock) {
if (MovieTicketManage.count>0) {
System.out.println(Thread.currentThread().getName()+"售出了第"+MovieTicketManage.count+"张电影票..");
MovieTicketManage.count--;
}
}
try {
Thread.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
3、创建MovieTicketManage类：（票管理类，存储电影票数量，为了多线程数据的共享）
public class MovieTicketManage {
public static int count = 100;
}
4、创建CinemaSale主类：（电影票售票主类）
public class CinemaSale {
public static void main(String[] args) {
Object lock = new Object();
WindowThread windowThread = new WindowThread(lock);
AppThread appThread = new AppThread(lock);
new Thread(windowThread,"窗口").start();
new Thread(appThread,"APP手机").start();
}
}
需要创建一把相同的锁lock，将这把锁传入AppThread和WindowThread线程类，保证锁的唯一，如果在AppThread线程和WindowThread线程里面创建锁，那么就是不同对象的锁了。就不能保证共享数据的同步，通过定义一个成员变量lock，通过构造方法将这个锁传递过来.
这样在购买电影票的时候就不会产生线程冲突和死锁问题了！
