一.线程的概念
用户可以同时使用计算机听歌或打印文件，这种思想在JAVA中称为并发。
线程：并发完成的每一件事情称为线程；
一个程序中的方法有几条执行路径，就有几个线程；
进程：一个进程中可以有多个线程；
并行：多个CPU同时进行多件事情；
二.线程的创建
两种方式:1, 继承Thread类
class TestThread extends Thread {......}
2, 实现Runnable接口, 然后作为参数传入到Thread类的构造方法中
class TestThread implements Runnable {......}
实际开发中多采用第二种方法，因为可以继承其他类和实现多个接口；
线程创建示例：
ackage Test;
public class TestThread {
public static void main(String[] args) {//主线程
Mythread mt = new Mythread();
mt.start();//继承Thread类后调用start方法启动一个线程，该方法会自动执行run()方法，不能直接调用run()方法；
Mythread1 mt1 = new Mythread1();
Thread t = new Thread(mt1);//实例化Thread类，将Runnable的实现类作为参数传入该构造方法中
t.start();//启动另一个线程
for (int i = 0; i < 50; i++) {
System.out.println(i + "----------");
}
}
}
//第一种：继承Thread类，重写里面的run方法
class Mythread extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 50; i++) {
System.out.println(i + "===========");
}
}
}
//第二种：实现Runnable接口，重写里面的run方法
class Mythread1 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println(i + "############");
}
}
}
打印结果：
三.线程状态转换
线程的生命周期是从调用start方法开始到run方法结束；
导致阻塞的事件：比如程序在等待用户操作才能继续执行的情况；
四.线程的常用方法：
1.t.interrupt()---打断线程；t.stop()---终止线程；这两种方法会抛出异常，不推荐使用；
现采用在实现类中定义一个布尔值，需要关闭时改为false即可：
class Mythread1 implements Runnable {
static boolean flag = true;
@Override
public void run() {
while(flag) {
System.out.println(new Date());
}
}
}
2.setPriority()------设置优先级, 优先级的概念: 谁的优先级高, 谁执行的时间就多，默认都为5；
Thread里面的默认优先级:
Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY = 10
Thread.NORM_PRIORITY = 5
3.Thread.sleep(5000)------让线程睡眠5秒钟；
4.Thread.yield()-----线程的礼让，让出CPU执行其他线程；但并不保证一定会礼让；
5.t.join()------线程的加入，当一个线程使用该方法加入另一个线程时，另一个线程会等待该线程执行完毕再继续执行。
6.t.setName;t.getName------设置/获取线程的名字；
7.isAlive()------判断线程是否还活着, 调用start()之前和终止之后都是死的, 其他的都是活的;
五.线程间的通信
1.wait()-----线程等待，使线程从运行状态进入就绪状态；
wait()与sleep的区别：1.调用sleep()方法的线程不释放锁，但wait()方法线程释放锁；
2.wait()方法如不写时间参数会使线程无限等待下去，需要使用notify()或notifyAll()唤醒；
2.notify()------唤醒线程；
3.notifyAll()------唤醒全部线程；
六.线程同步(synchronized)与锁
1.模拟去银行取钱示例
package Test1;
public class Bank {
private static int money = 3000;
public synchronized void getMoney(int cash) {
if (money >= cash) {
money -= cash;
System.out.println("取出了" + cash + "元");
} else {
System.out.println("余额不足,剩余" + money + "元");
}
}
}
package Test;
import Test1.Bank;
public class Test {
public static void main(String[] args) {
Bank b = new Bank();
Person p1 = new Person(b);
Person p2 = new Person(b);
Thread t1 = new Thread(p1);
Thread t2 = new Thread(p1);
t1.start();
t2.start();
}
}
class Person implements Runnable{
Bank bank;
public Person(Bank bank) {
super();
this.bank = bank;
}
@Override
public void run() {
this.bank.getMoney(2000);
}
}
2.模拟去车站买票示例
package Test1;
public class Piao {
private int i = 5;
public synchronized void sail(String name) {
if(i > 0) {
System.out.println(name +"你买了第"+ i-- +"张票");
}else {
System.out.println(name +"票卖没了");
}
}
}
package Test1;
public class Testpiao implements Runnable {
Piao p = new Piao();
@Override
public void run() {
p.sail(Thread.currentThread().getName());//获取当前线程的名字
}
public static void main(String[] args) {
Testpiao tp = new Testpiao();
Thread td1 = new Thread(tp);
Thread td2 = new Thread(tp);
Thread td3 = new Thread(tp);
Thread td4 = new Thread(tp);
Thread td5 = new Thread(tp);
Thread td6 = new Thread(tp);
td1.setName("超人");
td2.setName("闪电侠");
td3.setName("蝙蝠侠");
td4.setName("绿巨人");
td5.setName("雷神");
td6.setName("美国队长");
td1.start();
td2.start();
td3.start();
td4.start();
td5.start();
td6.start();
}
}
3.死锁示例
package Test1;
public class Deadlock implements Runnable {
private static Object o1 = new Object();
private static Object o2 = new Object();
private int flag;
//两个线程锁住各自对象后都要锁住另一个对象才会解锁原对象，互不相让导致程序一直处于等待状态；
@Override
public void run() {
if (flag == 1) {
System.out.println("线程" + flag + "开始");
synchronized (o1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2) {
System.out.println("线程" + flag + "结束");
}
}
}
if (flag == 2) {
System.out.println("线程" + flag + "开始");
synchronized (o2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1) {
System.out.println("线程" + flag + "结束");
}
}
}
}
public static void main(String[] args) {
Deadlock d1 = new Deadlock();
Deadlock d2 = new Deadlock();
Thread t1 = new Thread(d1);
Thread t2 = new Thread(d2);
d1.flag = 1;
d2.flag = 2;
t1.start();
t2.start();
}
}