多线程
1多线程的两种使用方式
第一种：继承Thread类（不建议使用，因为无法多继承）
第二种：实现Runnable接口（建议使用）
栗子：直接用第二种
写一个类实现Runnable接口，并覆盖其中的方法
/*
* 1，该类实现Runnable接口
* 2，实现run（）方法
* 3，实例化该类，在new个Thread（Runnable），传入该类，用start启动
* */
class MyThreads implements Runnable{
@Override
public void run() {
for(int i=0;i<20;i++){
//线程都是有名字的，可以用Thread.currentThread()返回Thread对象，在掉用getName()获取该线程的名字
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
}
public static void main(String[] args) {
//1先实例化出自己的线程类
MyThreads mt = new MyThreads();
//2要用start（）方法启动线程，因为接口没有该方法所以需要Thread
//Threa可以传入Runnable参数,还可以传入一个线程的名字
Thread th = new Thread(mt,"MyThread");
//3要用start（）方法启动线程
th.start();
//main自己跑一个线程
for(int i=0;i<20;i++){
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
2线程的调度
看最顶层的图：1，Statr（）让线程进入Runnable状态（等待调用），调度表中轮到该线程时，就会进入Running（正在运行）
2，如果这时我不想在跑了，可以调用yield（）返回到Runnable（等待调用状态），（注意的是对多核的计算机可能无效）
3，sleep（）让该线程去睡觉，进入Blocke（睡觉状态，不会在去竞争），直到睡觉时间结束。
4，join（），让该线程一直运行完，其他的线程才能去运行
5，synchronized（同步）关键字会让一段代码上锁，直到这段代码运行完（线程的同步）
6，wait（）方法让该线程挂起来（暂停），不在参与竞争
7，notify（）方法会让线程从新运行起来，注意的是要在线程都要挂在同一个对象上（也就是同一把钥匙），并且是随机唤醒其中的任意对象。
3线程的终止
不应该调用stop（）方法，这样不安全（并且已经过时），最佳停止方法是自己写一个停止方法，在该方法内释放资源
看栗子：
/*
* 最佳停止方法
* 1，定义一个flag
* 2，break跳出循环
* 3，写一个停止方法
* */
class MyThre implements Runnable{
//1定义一个flag
private boolean flag = true;
@Override
public void run() {
for(int i=0;i<100;i++){
//2判断停止
if(!flag) break;
System.out.println("iiii"+i);
}
}
//停止方法
public void stopThread(){
flag = false;
//可以在这里释放资源
}
} public static void main(String[] args) {
MyThre mt = new MyThre();
Thread t = new Thread(mt);
t.start();
//main自己的线程
while(true){
if(mt.i>=30){ //当条件满足时，调用停止方法
mt.stopThread();
break;
}
}
}
4线程的同步
线程同步可以解决多线程竞争同一个资源保证其安全的一种手段
线程同步要用synchronized关键字，并且需要一个任意对象做为钥匙
当方法声明为同步方法是，会用this做为钥匙
栗子：
/*
* 线程同步
* */
class MyThreads implements Runnable{
//定义一把钥匙,也可以用this做钥匙
Object o = new Object();
int index = 0;
//实现的方法
@Override
public void run() {
synchronized (o) {
for(index =0;index<1000;index++){
System.out.println(Thread.currentThread().getName()+": "+index);
}
}
}
} public static void main(String[] args) {
MyThreads mt = new MyThreads();
//实例化两个线程
//这样就不会同时修改一个数据了
Thread t1 = new Thread(mt,"T1");
Thread t2 = new Thread(mt,"T2");
t1.start();
t2.start();
}
5同步问题（死锁）
用了线程同步后，如果操作不当会造成死锁等问题
栗子：
/*
* 线程死锁
* */
class MyThreads implements Runnable{
//定义两把钥匙
Object key1 = new Object();
Object key2 = new Object();
//
boolean flag = true;
//实现的方法
@Override
public void run() {
//1判断是否进入，
if(flag){
synchronized (key1) { //好人拿第一把钥匙进入
//2进来后就为false
flag = false;
System.out.println(Thread.currentThread().getName()+"我拿key1进来了");
//注意了，万一去睡觉了
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//拿第二把钥匙第二次进入
synchronized (key2) {
System.out.println(Thread.currentThread().getName()+"我拿key2进来了");
}
}
}else{
//第二条线程坏人先拿第二把钥匙进入
synchronized (key2) {
//进来后要设为true，能让线程一第二次进入
flag = true;
System.out.println(Thread.currentThread().getName()+"我拿key2进来了");
//注意了，万一去睡觉了
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//该线程要拿第一把钥匙再次进入
synchronized (key1) {
System.out.println(Thread.currentThread().getName()+"我拿key1进来了");
}
}
}
}
} public static void main(String[] args) {
MyThreads mt = new MyThreads();
//实例化两个线程
//这样就不会同时修改一个数据了
Thread t1 = new Thread(mt,"好人");
Thread t2 = new Thread(mt,"坏人");
t1.start();
t2.start();
}解析：一般都是同步嵌套容易造成死锁问题
第一条线程好人拿着第一把钥匙进去，然后就跑去睡觉（false了），这样第二条线程坏人就会拿着第二把钥匙进去，然后它又睡觉去了（true了），就轮到好人要拿第二把钥匙进去，但是这第二把钥匙在坏人手中，它又在睡觉，好人就永远不可能等到第二把钥匙，这样就会等到死，造成坏人也不不可能拿到第一钥匙。
6生产者和消费者（wait和notify）
假如：一个厨师不停的做食物，做一个顾客就吃一个，直到厨师做完
厨师就是生产者，顾客就是消费者
看例子：注意的是notify需要同一个对象做钥匙
厨师类：
/*
* 生产者：厨师
* */
class Cool implements Runnable{
String[] food; //一组要生产的食物
String foods; //生产好的食物
boolean falg; //判断是否做了食物
//构造方法
public Cool() {
food = new String[]{"米饭","汉堡","沙拉","火锅","排骨"};
falg = false; //开始是没做食物的
}
//做食物方法
public void make(){
//因为要一直做完才能拿去给顾客，所以要同步
//用自己做钥匙，应为顾客中也有厨师这个对象，要使用同一个对象做钥匙
synchronized (this) {
//判断是否做了食物
if(!falg){
try {
int index = new Random().nextInt(food.length);
foods = food[index]; //这里随机生产食物
System.out.println(Thread.currentThread().getName()+"：生产了"+foods);
//生产完就要将falg设为true
falg = true;
//生产完本来是要挂自己，然后等顾客吃完再notify自己
//但是因为notify是随机唤醒线程，所以万一顾客先抢到线程，顾客就会先挂起
//所以这里就先要将顾客线程先唤醒释放掉，然后再挂起自己
this.notify();
//然后再挂起自己
this.wait(); //wait()会抛异常，需要捕获
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//覆盖的方法
@Override
public void run() {
//不停的生产食物
for(int i=0;i<10;i++){
make();
}
}
}顾客类：
/*
* 消费者：顾客
* */
class Customer implements Runnable{
//需要厨师这个对象
Cool c;
//构造方法
public Customer(Cool c) {
this.c = c;
}
//吃方法
public void eat(){
// 一直要吃完才通知厨师去做，所以需要同步
//注意的要用同意把钥匙做对象
//这里要用厨师做钥匙
synchronized (c) {
//判断厨师是否做了食物
if(c.falg){
try {
System.out.println(Thread.currentThread().getName()+" :正在吃 "+c.foods);
//吃完要叫厨师做，先设为false，让食物为空，在唤醒厨师的线程
c.falg = false;
c.notify();
//吃完将自己挂起来，等厨师去做
c.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
//这里如果是顾客先抢到线程，但厨师还没做，这时就要把自己挂起来，等厨师的线程去做
//所以为什么前面先要唤醒线程，在去挂起
try {
c.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//实现方法
@Override
public void run() {
//不停的吃
while(true){
eat();
}
}
}启动类：
public static void main(String[] args) {
Cool c = new Cool(); //实例化厨师
Customer cu = new Customer(c); //实例化顾客
//创建线程，并未线程命名
Thread ct = new Thread(c,"厨师");
Thread cut = new Thread(cu,"顾客");
//这里注意的是因为顾客是while死循环不停吃食物
//当厨师生产完所有实物后要终止程序，所以要将顾客线程设为后台线程
//后台线程的意思是：当所有线程结束时，这个线程也就结束了。
//用setDaemon(true)方法，注意这个方法一定要在线程启动之前声明
cut.setDaemon(true);
//然后再启动线程
ct.start();
cut.start();
}厨师：生产了火锅
顾客 :正在吃 火锅
厨师：生产了米饭
顾客 :正在吃 米饭
厨师：生产了沙拉
顾客 :正在吃 沙拉
厨师：生产了米饭
顾客 :正在吃 米饭
..........
........
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
