线程篇

线程篇

抽象类中可以有抽象方法也可以有具体的方法，实现类中只能有具体的方法。

我们写的java代码其实就是一个可运行的程序，一旦运行就是进程了。里面的main（）方法其实就是一个线程。像我们的QQ，也是一串代码，没运行时是一个程序，运行后就是进程了，里面的多种方法就是线程。

public class TextThread1 extends Thread{
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("1"+i);
        }
    }

    public static void main(String[] args) {
        TextThread1 textThread1 = new TextThread1();
        textThread1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("2"+i);
        }
    }
}

1.创建类要继承thread类

2.要重写run方法

3.在main（）里将类实例化执行start（）方法。

继承thread类

1.子类通过extends继承thread类，子类就可以有多线程

2.子类要进行实例化，然后子类对象。start（）就可以了

runnable

1.子类通过implements继承接口runnable

2.对子类进行实例化，然后new thread（子类对象,参数）。start（）

或者Thread thread=new Thread(子类对象)

thread.start();

继承接口runnable
public class Demo2 implements Runnable{
    private int ticketNums=10;
    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }
            //通过Thread.currentThread().getName()来获取name值
            System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
        }
    }

    public static void main(String[] args) {
    //多个线程，通过name来区分
        Demo2 demo2 = new Demo2();
        new Thread(demo2,"小明").start();
        new Thread(demo2,"大肖").start();
        new Thread(demo2,"xiao孩").start();
    }
}

监控，捕获异常是ctrl+alt+t快捷键生成try和catch

package thread;
//模拟龟兔赛跑
public class Demo3 implements Runnable{

    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子休息，每当兔子走了十步休息1ms
            if (Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            boolean flag=gameover(i);
//判断flag是否为true，是的话跳出循环
            if (flag){
                break;
            }
            //获取名字
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }

   private boolean gameover(int steps){
if (winner!=null){
    return true;
}{
    if (steps>=100){
        winner=Thread.currentThread().getName();
        System.out.println("胜利者是"+winner);
        return true;
    }
}
return  false;
   }
//将Demo3实例化，再调用start方法
    public static void main(String[] args) {
        Demo3 demo3 = new Demo3();
        new Thread(demo3,"兔子").start();
        new Thread(demo3,"乌龟").start();
    }
}

//静态代理真实角色
package thread;

public class Demo5 {
    public static void main(String[] args) {
        weddingCompany weddingCompany = new weddingCompany(new You());
        weddingCompany.happyMarry();

    }
}
interface Marry{
    void happyMarry();
}
//真实角色
class You implements Marry{
    public void happyMarry() {
        System.out.println("裂开");
    }
}
//代理角色
class  weddingCompany implements Marry{
private  Marry target;
public  weddingCompany(Marry target){
    this.target=target;
}
    @Override
    public void happyMarry() {
    before();
this.target.happyMarry();
after();
    }

    private void after() {
        System.out.println("结婚之后");
    }

    private void before() {
        System.out.println("结婚之前，布置现场");

    }
}

package thread;

public class Demo7 {

    public static void main(String[] args) {
//lambda表达式
      Ilove love=(int a) -> {
              System.out.println("i love you"+a);
      };
      //简化lambda
        love=(a) -> {
            System.out.println("i love you"+a);
        };

        love.love(2);
    }
}
//接口
interface Ilove{
    void love(int a);
}
class Love implements Ilove{
    @Override
    public void love(int a) {
        System.out.println("i love you"+a);
    }
}

lambda是函数式接口才行，函数式接口：只有一个接口，接口里只有一个方法

package thread;

import java.text.SimpleDateFormat;
import java.util.Date;
//打印当前时间
public class Demo10 {
    public static void main(String[] args) throws InterruptedException {
//获取当前时间
        Date startTime = new Date(System.currentTimeMillis());
    while (true){
        try {
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
        startTime=new Date(System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    }
    public static void tenDown()throws InterruptedException{
        int num=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

thread。join插队，强制执行

thread。yield礼让，不一定成功

thread.setprioriay优先级高的话概率大不一定先执行

package thread;
//银行取钱
public class UnsafeBanl {
    public static void main(String[] args) {
        Account account = new Account(100,"旅游");
        Drawing giflfriend = new Drawing(100,"giflfriend",account);
        Drawing me = new Drawing(50,"me",account);
    me.start();
    giflfriend.start();
    }
}
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
class Drawing extends Thread{
    Account account;//账户
    int drawingmoney;
    int nowmoney;
    public Drawing(int drawingmoney,String name,Account account){
        super(name);
        this.account=account;
        this.drawingmoney=drawingmoney;




    }
    public void run(){
        if (account.money-drawingmoney<0){
            System.out.println(Thread.currentThread().getName()+"没钱了");
        return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money=account.money-drawingmoney;
        nowmoney=nowmoney+drawingmoney;
        System.out.println(account.name+"余额为"+account.money);
        System.out.println(this.getName()+"手里的钱"+nowmoney);
    }
}

package thread;

public class UnsafeBanl {
    public static void main(String[] args) {
        Account account = new Account(100,"旅游");
        Drawing giflfriend = new Drawing(100,"giflfriend",account);
        Drawing me = new Drawing(50,"me",account);
    me.start();
    giflfriend.start();
    }
}
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
class Drawing extends Thread{
    Account account;//账户
    int drawingmoney;
    int nowmoney;
    public Drawing(int drawingmoney,String name,Account account){
        super(name);
        this.account=account;
        this.drawingmoney=drawingmoney;




    }
    //利用syn同步方法锁住account对象，syn默认对象是this对象即Drawing
    public synchronized void run(){
        synchronized (account){
            if (account.money-drawingmoney<0){
                System.out.println(Thread.currentThread().getName()+"没钱了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money=account.money-drawingmoney;
            nowmoney=nowmoney+drawingmoney;
            System.out.println(account.name+"余额为"+account.money);
            System.out.println(this.getName()+"手里的钱"+nowmoney);
        }
        }

}

package thread;
//死锁
public class Lock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2= new Makeup(1,"白雪公主");
g1.start();
g2.start();
    }
}
//口红
class Lip{

}
//镜子
class Mirror {

}
class  Makeup extends Thread{
    //用static来保证只有一个,保证互斥
    static Lip lip=new Lip();
    static Mirror mirror=new Mirror();
    int choice;
    String girlName;
    Makeup(int choice,String girlName){
        this.choice=choice;
        this.girlName=girlName;
    }
    @Override
    public void run() {
       //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //化妆，互相持有对方的资源
    private void makeup() throws InterruptedException {
if (choice==0){
    synchronized (lip){
        System.out.println(this.girlName+"获得口红的锁");
        Thread.sleep(1000);

    }
    //用完lip释放lip
    synchronized (mirror){
        System.out.println(this.girlName+"获得镜子的锁");
    }
}
else {
    synchronized (mirror){
        System.out.println(this.girlName+"获得镜子的锁");
        Thread.sleep(2000);

    }
    //用完mirror后释放
    synchronized (lip){
        System.out.println(this.girlName+"获得口红的锁");
    }
}
    }
}
输出结果：
灰姑娘获得口红的锁
白雪公主获得镜子的锁
白雪公主获得口红的锁
灰姑娘获得镜子的锁

当一个同步块里有两个锁，可能会产生死锁

package thread;

import java.util.concurrent.locks.ReentrantLock;

public class Threadfinally {
    public static void main(String[] args) {
        Lock2 lock2=new Lock2();
        new Thread(lock2).start();
        new Thread(lock2).start();
        new Thread(lock2).start();
    }
}
class Lock2 implements Runnable{
    int tickNums=10;
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){

            try {
                lock.lock();//加锁
                if (tickNums>=0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(tickNums--);
                }else {
                    break;
                }
            }finally {
lock.unlock();

            }

        }
    }
}
//lock锁

package thread;
//生产者，消费者问题--利用缓存区解决：管程法
public class Pc {
    public static void main(String[] args) {
        SynContain contain=new SynContain();
        new Productor(contain).start();
        new Condumer(contain).start();

    }
}
//生产者
class Productor extends Thread{
    SynContain container;
    public Productor(SynContain container){
        this.container=container;
    }
//生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(i));
        }
    }
}
//消费者
class Condumer extends Thread{
    SynContain container;
    public Condumer(SynContain container){
        this.container=container;
    }

    @Override
    //消费
    public void run() {

        for (int i = 0; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}
//缓存区
class SynContain{
    //容量大小
    Chicken[] chickens=new Chicken[10];
    //容量计数器
    int count=0;
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容量满了，就需要等待消费者消费
if (count== chickens.length){
    //通知消费者消费，生产等待
    try {
        this.wait();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
//如果没满。我们就可以丢入产品
        chickens[count]=chicken;
count++;
this.notifyAll();
//可以通知消费者消费
    }
    public synchronized Chicken pop(){
        //判断能否消费
        if (count==0){
            try {
                this.wait(); //等待生产者生产，消费者等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //等待生产者生产，消费者等待
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];
        //通知生产者生产
        this.notifyAll();
        return chicken;
    }

}

//生产者，消费者问题，通过boolean标志位模拟信号灯
package thread;

public class Pc2 {
    public static void main(String[] args) {
        Tv tv=new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
class Player extends Thread{
Tv tv;//tv对象
public Player(Tv tv){
this.tv=tv;
}

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                try {
                    this.tv.play("快乐大本营");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                try {
                    this.tv.play("抖音");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class Watcher extends Thread{
    Tv tv;
    public Watcher(Tv tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                tv.watch();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Tv{
String voice;
boolean flag=true;
public synchronized void play(String voice) throws InterruptedException {
    if (!flag){
        wait();
    }
    System.out.println("演员表演了："+voice);
    //通知观众观看
    this.notifyAll();
    //让他更新voice，flag
    this.voice=voice;
    this.flag=!this.flag;
}
public synchronized void watch() throws InterruptedException {
    if (flag){
        wait();
    }
    System.out.println("观众观看了"+voice);
    this.notifyAll();
    this.flag=!this.flag;
}
}

package thread;

import java.util.concurrent.Callable;

//总结线程创建
public class New {
    public static void main(String[] args) {
        //1.thread
        MyThread1 myThread1 = new MyThread1();
        myThread1.start();
        //2.runnable
        MyThread2 myThread2 = new MyThread2();
        new Thread(myThread2).start();
    }
}
//1.继承Thread
class MyThread1 extends Thread{
    @Override
    public void run() {

        System.out.println("MyThread1");
    }
}
//实现runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}
//实现callable接口
class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 100;
    }
}
输出结果：
MyThread1
MyThread2

synchronized是对本类的进行同步，解决线程不安全的问题
如果要实现生产者消费者问题的话还要和wait（）和notifyall（）