java学习-线程

由于自己最近接手一个项目，构思过程中，线程可能会用的较多,所以今天翻出来把线程这块好好复习一下，以下是一点学习总结。分享写的比较拙略，只为自己笔记。为自己以后存储参考资源而已。
  pass:（被重写的方法不能跑一个比父类更大的异常）

创建于一个继承thread的子类：

class testThread extends Thread{
    public void Run(){//新建一个线程里的run方法，实现此子线程需要完成的功能
        for(int i = 0;i < 100;i++){
            Thread.currentThread().sleep(1000);
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread{
   static void main(String arg[]){
      testThread sT1 = new testThread();
      testThread sT2 = new testThread();//创建一个子类的对象
      sT1.setName("线程1：");
      sT1.setpriority(Thread.MAX.PRIORITY);
      sT1.start();
      sT2.setName("线程2：");
      sT2.start();
      //调用线程的start方法，启动此线程，调用相应的run方法，
      //一个线程只能执行一次start，具体请见jdk手册。
      //如果此处启用的是run方法，则不是双线程。必须是start方法。
   Thread.currentThread().setName("子线程：");
    for(int i = 0;i < 100;i++){
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"i);
        /*if(i % 10 == 0){
            Thread.currentThread().yield();
            
        }*/
        /*if(i % 10 ==0){
            try{
                sT1.join();
            }catch(InterruptedException e){
               e.printStackTrace();
            }
        }*/
        }
        System.out.println(sT1.isAlive());/*返回FALSE*/
   }
}

Thread常用方法：
1.start() 启动线程并执行相应的run方法。
2.run()  子线程要执行的代码放入其中，一般都是被重写。
3.currentThread() 静态的，调取当前的线程
4.getName() 获取当前线程的名字
5.setName() 设置子线程的名字
6.yield()  线程释放当前cpu的执行权
7.join() 在a线程中调用b线程的join方法，表示，当执行到此方法，a线程停止，直至b线程全部结束，a线程才继续执行
8.isAlive() 判断当前线程是否还存活
9.sleep(long l) 显示的当前线程睡眠1毫秒
10.设置线程的优先级：getpriority() 返回线程优先级；setpriority(int newpriority)改变线程的优先级

/*
  创建两个子线程，让其中一个输出1-100之间的偶数，另一个输出1-100之间的奇数
*/
class SubThread1 extends Thread{
    public void Run(){
        for (int i = 1; i < 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class SubThread2 extends Thread{
    public void Run(){
        for (int i = 1; i < 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
    public class TestThread{
            public static void main(String[] args) {
                 SubThread sT1 = new SubThread1();
                  SubThread sT2 = new SubThread();
                  //sT1.start();
                  //sT2.start();
                  //继承于Thread类的匿名对象
                  new Thread(){
                    public void Run(){
                     for (int i = 1; i < 100;i++){
                       if(i % 2 != 0){
                         System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }}.start();
                 new Thread(){
                    public void Run(){
                     for (int i = 1; i < 100;i++){
                       if(i % 2 != 0){
                         System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }}.start();

            }
    }

/*模拟火车站首售票窗口，开启三个窗口售票.总票数为100张*/
 class Window extends Thread{
        static int tickets = 100;//声明为固定变量实现公用，限制只有一百张，但声明周期很长
         public void Run(){
             while(true){
                 if(tickets > 0){
                     System.out.println(Thread.currentThread().getName()+"售票.票号为："+ tickets--);
                 }else{
                     break;//退出
                 }
             }
         }
 }
 public class TestWindow{

 }

 public static void main(String[] args) {
     Window W1 = new Window();
     Window W2 = new Window();
     Window W3 = new Window();

     W1.setName("窗口1：");
     W2.setName("窗口2：");
     W3.setName("窗口3：");

     W1.start();
     W2.start();
     w3.start();
 }

第二种方式-实现:

//1.创建一个实现了runable的类 
class PrintNum1 implements Runable{
    public void run(){//实现接口的抽象方法
         for (int i = 1; i < 100;i++){
                       if(i % 2 != 0){
                         System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class TestWindow1{
    public static void main(String[] args) {
        //2.创建一个runable接口的实现对象
        PrintNum1 p = new PrintNum1();
        //要想启动一个多线程，必须调用start方法
        //3.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程。
        Thread T1 = new Thread(p);//构造一个Thread对象
        T1.start();
         //启动线程，执行Thread对象生成时构造器形参的对象的Run方法

        //4.在创建一个线程
        Thread T2 = new Thread(p);//构造一个Thread对象
        T2.start();
    }
 }

实现的方式实现多窗口售票 存在线程的安全问题
为何会出现程序的安全问题？
由于一个线程在操作共享数据的执行过程中未执行完的情况下，另外的线程参与进来，导致共享数据存在安全问题
如何解决？
必须让一个操作共享数据完毕之后，其他线程才有机会共享数据的操作。
java如何实现线程安全？
线程的同步：1.同步代码块 synchronized（同步监视器）{
    需要同步的代码块（操作数据共享的代码）
}
共享数据：多个线程共同操作的一个数据
同步监视器：由任何一个类的对象来充当，那个线程获取此监视器，谁就执行大括号里面的代码 俗称：锁
在实现的方式中考虑同步的话可以考虑this来充当锁，但在继承当中需要慎重.

class Window1 implements Thread{
    int ticket = 100;//共享数据
    static Object object = new Object();
    public void run(){
        //Object object = new Object();不能在此处写，这样会导致引发三次局部变量
        while(true){
            synchronized(object){//此处可以为this，代表当前的对象W1
                 if(tickets > 0){
                     try{//这个地方会出现重票和错票

                        Thread.currentThread().sleep(10);//让其休眠10毫秒
                     }catch(InterruptedException e){
                       e.printStackTrace();
                     }
                     System.out.println(Thread.currentThread().getName()+"售票.票号为："+ tickets--);
                 }else{
                     break;//退出
             }
         }
          }
    }
}
public class TestWindow1{
  public static void main(String[] args) {
      Window1 W1 = new Window1();
      Thread t1 = new Thread(W1);
      Thread t2 = new Thread(W1);
    /*只new了一个w对象，三个线程共享*/
      t1.setName("窗口1：");
     t2.setName("窗口2：");
     
      t1.start();
  //共享同一个W对像
      
      t2.start();

  }

}

/*实现改进版售票器*/
class Window1 implements Thread{
    int ticket = 100;
    public void run(){
        while(true){
                 if(tickets > 0){
                     /*try{//这个地方会出现重票和错票
   
                        Thread.currentThread().sleep(10);//让其休眠10毫秒
                     }catch(InterruptedException e){
                       e.printStackTrace();
                     }*/
                     System.out.println(Thread.currentThread().getName()+"售票.票号为："+ tickets--);
                 }else{
                     break;//退出
             }
          }
    }
}
public class TestWindow1{
  public static void main(String[] args) {
      Window1 W1 = new Window1();
      Thread t1 = new Thread(W1);
      Thread t2 = new Thread(W1);
    /*只new了一个w对象，三个线程共享*/
      t1.setName("窗口1：");
     t2.setName("窗口2：");
     
      t1.start();
  //共享同一个W对像
      
      t2.start();

  }

同步方法
将操作共享数据的方法声明为synchronized，
即此方法为同步方法，能够保证当其中一个线程执行此方法时，
其他线程在外等待直到此线程执行完此方法
>同步方法的锁是当前对象：this
线程的弊端：同一个时间只有一个线程访问共享数据，效率变低了。

/*实现改进版售票器*/
class Window1 implements Thread{
    int ticket = 100;
    public void run(){
        while(true){
        show();

        }
    }
    public synchronized void show(){
    
                 if(tickets > 0){
                     try{//这个地方会出现重票和错票
                        Thread.currentThread().sleep(10);//让其休眠10毫秒
                     }catch(InterruptedException e){
                       e.printStackTrace();
                     }
                     System.out.println(Thread.currentThread().getName()+"售票.票号为："+ tickets--);
                 }else{
                     break;//退出
             
          }
    }
}
public class TestWindow1{
  public static void main(String[] args) {
      Window1 W1 = new Window1();
      Thread t1 = new Thread(W1);
      Thread t2 = new Thread(W1);
    /*只new了一个w对象，三个线程共享*/
      t1.setName("窗口1：");
     t2.setName("窗口2：");
     
      t1.start();
  //共享同一个W对像
      
      t2.start();

  }

/*继承实现同步方法*/
class Window extends Thread{
        static int tickets = 100;//声明为固定变量实现公用，限制只有一百张，但声明周期很长
        static Object o = new Object();
         public void Run(){
             while(true){
                 synchronized(o){
                 if(tickets > 0){
                     System.out.println(Thread.currentThread().getName()+"售票.票号为："+ tickets--);
                 }else{
                     break;//退出
                 }
               }
             }
         }
 }
 public class TestWindow{
 public static void main(String[] args) {
     Window W1 = new Window();
     Window W2 = new Window();
     Window W3 = new Window();

     W1.setName("窗口1：");
     W2.setName("窗口2：");
     W3.setName("窗口3：");

     W1.start();
     W2.start();
     w3.start();
 }
}

/*懒汉模式-单例模式
sleep()和yield()不会释放锁的，
static方法里面锁不能写this，使用当前类本身充当*/
class  Singleton{
   private Singleton(){

   }
   private static Singleton instance = null;
   public static Singleton getInstance(){
       if(instance == null){
       synchronized(Singleton.class){
       if(instance == null){
           instance = new Singleton();
       }
       }
       }
       return instance;
   }
 }


 public class TestSingleton{
  public static void main(String[] args) {
      Singleton s1 = new Singleton.getInstance();
      Singleton s2 = new Singleton.getInstance();

      System.out.println(s1 == s2);//判断两个对象相等，只能用==
  }
 }

/*银行存钱问题
*/
class Count{
    double balance;//余额
    public Account(){

    }    
    public synchronized void despoit(double amt){//存钱
      notify();//实现二者交替打印
      balance += amt;
      try{
          Thread.currentThread().sleep(10);
      }
      catch(InterruptedException e){
            e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName()+":"+balance);
      wait();
    }

}
class Customer extends Thread{
    Account account;
    public Customer(Account account){
        this.account = account;
    }
    public void run(){
       for(int i = 0;i<3;i++){
           account.despoit(1000);
       }
    }
}
public class TestAccount{
   public static void main(String[] args) {
       Account acct =new Account();
       Customer c1 = new Customer(acct);
       Customer c2 = new Customer(acct);
       Customer c3 = new Customer(acct);

       c1.setName("1");
       c2.setName("2");
       c3.setName("3");

       c1.start();
       c2.start();
       c3.start();
   }
}

/*死锁问题--处理线程同步时容易出现
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的资源，就形成了线程的死锁*/
 public class TestDeadLock{
     static StringBuffer sb1 = new StringBuffer();
     static StringBuffer sb2 = new StringBuffer();

     public static void main(String[] args) {
         new Thread(){
              public void run(){
               synchronized(sb1){
                try{
                    Thread.currentThread().sleep(10);
                  }
                   catch(InterruptedException e){
                     e.printStackTrace();
                  }
                sb1.append("A");
                  synchronized(sb2){
                    sb2.append("B");
                     System.out.println(sb1);
                     System.out.println(sb2);
                   }
                }
              }
         }.start();

         new Thread(){
             public void run(){
               synchronized(sb1){
                   try{
                    Thread.currentThread().sleep(10);
                  }
                   catch(InterruptedException e){
                     e.printStackTrace();
                  }
                sb1.append("C");
                  synchronized(sb2){
                    sb2.append("D");
                    System.out.println(sb1);
                     System.out.println(sb2);
                   }
                }
             }
         }.start();
     }
 } 

/*Deadlock.java*/
class A{
    public synchronized void foo(B b){
        System.out.println("当前线程名："+Thread.currentThread().getName()+"进入了A实例的foo方法");
        try{
            Thread.sleep(200)
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("当前线程名："+Thread.currentThread().getName()+"企图调用b的last方法");
    }
    public synchronized void Last(){
        System.out.println("进入了A的last方发出内部")；
    }
}

class B{
   public synchronized void bar(A a){
     System.out.println("当前线程名："+Thread.currentThread().getName()+"进入了B实例的bar方法");try{
            Thread.sleep(200)
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("当前线程名："+Thread.currentThread().getName()+"企图调用A的last方法");
    }
    public synchronized void Last(){
        System.out.println("进入了B的last方发出内部")；
    }
}
public class Deadlock implements Runable{
    A a = new A();
    B b = new B();

    public void init(){
        Thread.currentThread.setName("主线程");
        //调用a对象的foo方法
        a.foo(b);
        System.out.println("进入了主线程之后");
    }
    public void run(){
        Thread.currentThread.setName("副线程");
       //调用b对象的bar方法
        b.bar(a);
        System.out.println("进入了副线程之后");
    }
    public static void main(String[] args) {
        Deadlock d1 = new Deadlock();
        new Thread(d1).start();//启动run方法
        d1.init();
    }
}

线程通信：
1.wait()方法：令当前线程挂起并放弃CPU，同步资源，使别的线程可访问并修改资源，而当前线程排队等候再次对资源的访问
2.notify()方法：唤醒正在排队等待同步资源的线程中优先级最高的
3.notifyAll()方法：唤醒正在等待资源的所有线程结束等待
java.lang.Object提供的这三个方法只有在synchronized方法中或synchronized代码块中才能使用，否则会报错
线程通信：

打印1-100，线程1，线程2交替打印*/
class PrintNum implements Runable{
    int num = 1;
       public void run(){
           
           while(true){
            synchronized(this){
                notify();
               if(num<100){
                   try{Thread.currentThread().sleep(10);
                   }catch(InterruptedException e){
                     e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName()+":"+num);
                   num++;
               }else{
                   break;
             }
             wait();
         }
           }
       }
}

public class TestCommunication{
    public static void main(String[] args) {
        PrintNum p = new PrintNum();
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(p);

        t1.setName("甲");
        t1.setName("乙");

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

}

生产者、消费者问题
多线程：消费者/生产者
共享数据:产品数量

class Clerk{//店员
    int product;

    public synchronized void addProduct(){//生产产品
        if(product >= 20){
            wait();
        }else{
            product++;
            System.out.println(Thread.currentThread().getName()+":生产了第"+ product +"个");
            notifyall();
        }

    }
    public synchronized void consumeProduct(){//消费产品
        if(product <= 0){
            wait();
        }else{
            System.out.println(Thread.currentThread().getName()+"消费了第"+product +"个");
            product--;
            notifyall();
        }
    }
}
class Producer implements Thread{//生产者
    Clerk clerk;

    public Producer(Clerk clerk){
        this.clerk = clerk;
    }
    public void run(){
        System.out.println("生产者开始生产产品。");
        while(true){
            try{ 
                Thread.currentThread().sleep(10);
                   }catch(InterruptedException e)
                   {
                     e.printStackTrace();
                   }
            clerk.addProduct();
        }
    }

}
class Consumer implements Runable{//消费者
     Clerk clerk;
     public Consumer(Clerk clerk){
         this.clerk = clerk;
     }
     public void run(){
         System.out.println("消费者开始消费产品。");
         while(true){
            try{
                Thread.currentThread().sleep(10);
                   }catch(InterruptedException e) 
                   {
                     e.printStackTrace();
                   }
             clerk.consumeProduct();
         }
     }
}