Java入门10--线程

oop

---

class
类成员
－－－－－－－－－－－－－－－－－－－－

构造函数：和类同名，没有返回值，可以重载
					this(),super(x,s,s,s);
成员变量：private public final
成员函数：
静态代码块：类加载
｛｝　//构造代码块
extedns
单重继承，可以多层继承

－－－－－－－－－－－－－－－－
抽象类

abstract 修饰类，不能实例化。

－－－－－－－－－－－－－－－－－－－－
抽象方法

没有方法体的方法　abstract
抽象类才能有抽象方法，等待子类实现这个方法

－－－－－－－－－－－－－－－－－－
ｆｉｎａｌ

final class //不能继承
final 方法 //不能重写
final 变量 //不能被重新赋值，即为常量

－－－－－－－－－－－－－－－－－－
内部类

package d6;
class neibu {
    public static void main(String[] args) {
        Benz.Engine e = new Benz.Engine();
        e.fire();

    }
}
class Benz{
    private String color;
    private int tires;
    //内部类
    static class Engine{
        public void fire(){
            System.out.println("fire---");
        }
    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
非法组合

abstract + private
abstract + final
private + final //不是非法的，

－－－－－－－－－－－－－－－－－－
ＪＶＭ

方法区
栈区：循环栈溢出－Ｘｓｓ
队区:－Ｘｍｘ（ｍａｘ）　－Ｘｍｓ(初始值)

接口

interface.

**格式**
interface{ }

=======================================

---

+++

=========================================

线程

class neibu {
    public static void main(String[] args) {
        Benz.Engine e = new Benz.Engine();
        e.fire();

    }
}
class Benz{
    private String color;
    private int tires;
    //内部类
    static class Engine{
        public void fire(){
            System.out.println("fire---");
        }
    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

class ThreadDemo1{
    public static void main(String[] args){
        MyThread t1 = new MyThread("Thread-1");
        MyThread t2 = new MyThread("Thread-2");

        t1.start();
        t2.start();
    }
        }

class MyThread extends Thread{
    private String name;
    public MyThread(String name){
        this.name = name;

    }
    public void run(){
        for(;;){
            System.out.println(name);
        }
    }
}

java.lang.Thread

**1.Thread.yield()方法
　放弃ｃｐｕ强占权
２．Thread.join()
ｔ2.join 加入当前线程的执行序列
当前线程等待指定的线程结束后才能继续执行
Ｔhread t = …
t.join();
…

**

Thread.setDaemon(true);

==========================================

    public void run(){
        for(;;){
            System.out.println(name);
            //yield　　放弃ｃｐｕ的抢占权
            Thread.yield();
        }
    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
３．Thread.sleep()
让当前线程休眠指定的ｓ
Ｔhread.join()
t.join//等待ｔ结束后再去执行

class ThreadDemo1{
//    public static void main(String[] args){
//        MyThread t1 = new MyThread("Thread-1");
//        MyThread t2 = new MyThread("Thread-2");

//        t1.start();
//        t2.start();
        public static void main(String[] args){
            Player p1 = new Player("张三",2000);
            Player p2 = new Player("李四",1000);
            Player p3 = new Player("王五",1500);
            Player p4 = new Player("周六",3000);

            p1.start();
            p2.start();
            p3.start();
            p4.start();

            try {
                p1.join();
                p2.join();
                p3.join();
                p4.join();
            }
            catch (Exception e){

            }


            System.out.println("开局");
        }
    }


class Player extends Thread{
    private String name;
    private int time;
    public Player(String name,int time){
        this.name = name;
        this.time = time;

    }

public void run(){
    System.out.println(name+"出发了");
    try{
        Thread.sleep(time);
    }
    catch (Exception e){}
    System.out.println(name+"到了!耗时："+time);
    }
}

===================
4.daemon　
守护线程，给其他线程提供服务，类似于服务员
如果进程中剩余的线程都是守护线程，则进程终止

package d6;

public class t4 {
    public static void main(String args[]){
        Box no1 = new Box("No1",3000);
        Box no2 = new Box("no2",7000);

        Waiter w = new Waiter();
        //设置服务员为守护线程
        w.setDaemon(true);

        no1.start();
        no2.start();

        w.start();
    }
}

class Box extends Thread{
    private String no;
    private int time;
    public Box(String no,int time){
        this.no = no;
        this.time = time;
    }
    public void run(){
        System.out.println(no + "号开始消费");
        try{
            Thread.sleep(time);
        }
        catch (Exception e){}
        System.out.println(no + "消费时间" + time + ",结束消费");

    }
}

//服务员累　线程
class Waiter extends Thread{
    public void run(){
        while (true){
            //打印当前系统时间
            System.out.println(new java.util.Date());
            try{Thread.sleep(1000);}
            catch (Exception e){}
        }
    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
**
原子性操作**

public class t5 {
    public static void main(String args[]){
        Saler s1 = new Saler("s1");
        Saler s2 = new Saler("s2");

        s1.start();
        s2.start();
        s1.run();
//        s2.run();
    }

}

class Saler extends Thread{
    static int tickets = 100;
    private String name;

    public Saler(String name){
        this.name = name;
    }
    public void run(){
        while (tickets > 0){
            System.out.println(name + " : " + (tickets--));
        }

    }
}

tickets还没执行－１操作，就被线程２抢占去了ｃｐｕ，会出现

public void run(){
        while (tickets > 0){
            int temp = tickets;

            System.out.println(name + " : " + temp);
            tickets = tickets - 1;
        }

    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
６解决方法－－加锁
线程间通信，共享资源的问题
防止并发访问，由并行改为串行
参照物：锁旗标

public class t5 {
    public static void main(String args[]){
        Saler s1 = new Saler("s1");
        Saler s2 = new Saler("s2");

        s1.start();
        s2.start();
        s1.run();
//        s2.run();
    }

}

class Saler extends Thread {
    static int tickets = 100;
    static Object lock = new Object();
    private String name;

    public Saler(String name) {
        this.name = name;
    }

    public void run() {
        while (true) {
            int t = getTickets();
            if (t < 1) {
                return;
            } else {
                System.out.println(name + " : " + t);
            }
        }

    }

    //取票
    public int getTickets() {
        //加锁　同步代码块，同是只能执行一个
        synchronized (lock) {


            int t = tickets;
            tickets = tickets - 1;
            return t < 1 ? -1 : t;
        }
        //return -2;
    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝
票池和同步代码块加锁的问题

package d6;

public class t7 {
    public static void main(String[] args){
        TickerPool pool = new TickerPool();
        Saler1 s1 = new Saler1("s1",pool);
        Saler1 s2 = new Saler1("s2",pool);
        Saler1 s3 = new Saler1("s3",pool);
        Saler1 s4 = new Saler1("s4",pool);
        Saler1 s5 = new Saler1("s5",pool);

        s1.start();
        s5.start();
        s4.start();
        s3.start();
        s2.start();
    }
}
//售票员
class Saler1 extends Thread{
    private String name;
    private TickerPool pool;
    public Saler1(String name,TickerPool pool){
        this.name = name;
        this.pool = pool;
    }

    public void run(){
        while(true){
            int no = pool.getTickets();
            if(no == 0){
                return;
            }
            else {
                System.out.println((no++) + " : "+ name + " : " + no);
            }
        }
    }


}
//票池
class TickerPool{
    private int tickets = 100;

    public int getTickets(){
        //同步代码块，以票池本身作为锁旗标
        synchronized (this){
            int temp = tickets;
            tickets = tickets -1 ;
            return temp > 0 ? temp : 0 ;
        }
    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

集合

ｌｉｓｔ：　java.util.List

// list为接口，不能实现(ｎｅｗ),应该ｎｅｗ一个实现类(ArrayList)
java.util.List<Integer> list = new java.java.util.ArrayList();
java.util.List<Integer> list = new java.java.util.ArrayList<integer>();
//集合当中只能方对象Integer

---

Interger 为 int 的包装类

Integer i = new Integer(100);

public class t8 {
    public static void main(String[] args){
        java.util.List<Integer> list = new java.util.ArrayList<Integer>();
        Productor p = new Productor("生产者",list);
        Consumer c = new Consumer("消费者",list);

        p.start();
        c.start();
    }

}
//生产者
class Productor extends Thread{
    private String name;
    private java.util.List<Integer> list;
    public Productor(String name ,java.util.List<Integer> list){
        this.name = name;
        this.list = list;
    }
    public void run(){
        int i = 0;
        while (true){
            list.add(new Integer(i ++));
        }

    }
}

//消费者
class Consumer extends Thread{
    private String name;
    private java.util.List<Integer> list;
    public Consumer(String name ,java.util.List<Integer> list){
        this.name = name;
        this.list = list;
    }
    public void run(){
        while (true){
            if(list.size() > 0){
                int i = list.remove(0);
                System.out.println(name + " 取出来　: " + i);

            }
        }
    }
}

＝＝＝＝＝
由于打印在消费者，打印很占用时间，所以生产比较快，不就出现栈溢出
＝＝＝＝＝

解决栈溢出：通知模式　生产一个通知消费一个　消费一个再通知生产一个

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Ｏｂｊｅｃｔ.ｗａｉｔ（）
Ｏｂｊｅｃｔ.ｎｏｔｉｆｙ（）

wait 让当前线程进入到锁旗标等待队列
释放cpu的抢占权，也释放锁旗标的监控权

notify 通知这个对象等待队列的线程，随机挑一个唤醒，一次只通知一个

public class t8 {
    public static void main(String[] args){
        Pool pool = new Pool();
 //       java.util.List<Integer> list = new java.util.ArrayList<Integer>();
        Productor p = new Productor("生产者",pool);
        Consumer c = new Consumer("消费者",pool);

        p.start();
        c.start();
    }

}
//生产者
class Productor extends Thread{
    private String name;
    private Pool pool;
//    private java.util.List<Integer> list;
    public Productor(String name ,Pool pool){
        this.name = name;
        this.pool = pool;
    }
    public void run(){
        int i = 0;
        while (true){
           pool.add(i ++);
            System.out.println("add : " + i + " ");
        }


    }
}

//消费者
class Consumer extends Thread{
    private String name;
    private Pool pool;
//    private java.util.List<Integer> list;
    public Consumer(String name ,Pool pool){
        this.name = name;
        this.pool = pool;
    }
    public void run(){
        while (true){
            int i = pool.remove();
            System.out.println("消费：" + i);
            }
        }
    }


//池子
class Pool{
    private java.util.ArrayList<Integer> list = new java.util.ArrayList<Integer>();

    //添加之前进行判断
    private int MAX = 100;
    //添加元素
    public void add(int n) {
        synchronized (this){
            if (list.size() > MAX) {
                try {
                    this.wait();
                    System.out.println("等待不运行，也不打印，被唤醒后打印");
                }
                catch (Exception e) {
                }
            }
            list.add(n);
        }

    }

    //删除元素
    public int remove() {
        try {
            if (list.size() == 0) {
//                return list.remove(0);
                this.wait();
            } else {
                int i = list.remove(0);
                this.notify();
                return i;
            }
            return -1;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return -1;
    }
    }
    

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
解决死锁的问题方式
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
ｎｏｔｉｆｙＡｌｌ（）通知所有线程可以抢占cpu和锁旗标监控权
ｗａｉｔ（１０００）