Thread



package com.edu_03;
/**
 * 实现Runable接口：
 *
 */
public class MyThread implements Runnable{
 @Override
 public void run() {
  //启动该线程对象之后，需要执行的代码
  for (int i = 0; i < 10; i++) {
   System.out.println(i);
  } 
 }

}

package com.edu_03;

public class Test {
 public static void main(String[] args) {
  //创建Mythread对象
  MyThread mt = new MyThread();
  //开启这个线程
  //mt.start();//这里的这个类仅仅是实现了Runnalble接口的一个类，但是start方法在Thread类中
  //但是我们想要开启一个线程，就必须调用start方法，请问怎么办？
  
  //public Thread(Runnable target)
  Thread t1 = new Thread(mt);
  t1.start();
  
  
 }

}

package com.edu_04;   
 (3)多线程的几个问题：
  A:启动线程用的是哪个方法
   start()
  B:start()和run()的区别
   start():1.开启线程  2.执行run()方法里面的代码
   run():执行的是线程里面执行的代码，并不会开启线程
  C:为什么要重写run()
   因为每个线程需要执行的代码都是都是不一样的，
   我们需要将每个线程自己独立执行的代码写到run()方法中执行
  D:线程可以多次启动吗

public class Test {
 public static void main(String[] args) {
  //B:start()和run()的区别
  // 创建一个线程独享
  MyThread mt = new MyThread();
  MyThread mt2 = new MyThread();
  //mt.start();//1.首先开启了一个独立的线程 2.让这个独立的线程执行run方法中的代码
  
  System.out.println("--------");
  //mt.run();//1.普通的创对象，调方法  2.代码实在主线程执行，不会开辟新线程
  
  
  //D:线程可以多次启动吗
  mt.start();
  //mt2.start();//如果是不同的线程对象，是可以同时开启的
  //mt.start();//线程是不能多次启动的
  
 }

}

package com.edu_05;
  (4)线程的调度和控制
  线程休眠(Thread.sleep(毫秒值))
  线程名称（setName(),getName();）
  线程的调度及优先级setPriority(10)（注意默认值是5，区间在1-10之间）
  什么叫线程优先级：说白了就是设置你抢占cpu执行权抢占到的概率
public class Test {
 public static void main(String[] args) {
  //线程名称（setName(),getName();）
  //创建3个线程对象
  MyThread t1 = new MyThread();
  MyThread t2 = new MyThread();
  MyThread t3 = new MyThread();
  
  //给三个线程设置姓名
  t1.setName("刘备");
  t2.setName("张飞");
  t3.setName("关羽");
  
  //设置线程的优先级
  //线程的调度及优先级setPriority(10)（注意默认值是5，区间在1-10之间）
  //t1.setPriority(100);//设置的区间必须在1-10之间
  t1.setPriority(10);
  
  //开启线程
  t1.start();
  t2.start();
  t3.start();
 }

}
package com.edu_06;

public class Test {
 public static void main(String[] args) {
  //创建三个线程并且启动三个线程
  MyThread mt = new MyThread();
  
  //创建县城对象
  Thread t1 = new Thread(mt);
  Thread t2 = new Thread(mt);
  Thread t3 = new Thread(mt);
  
  //给县城设置姓名
  t1.setName("刘备");
  t2.setName("关羽");
  t3.setName("张飞");
  
  //启动线程
  t1.start();
  t2.start();
  t3.start();
  
 }

}
package com.edu_07;
//5.1继承Thread卖票
public class Test {
 public static void main(String[] args) {
  //创建三个线程模拟三个售票窗口
  MyThread mt1 = new MyThread();
  MyThread mt2 = new MyThread();
  MyThread mt3 = new MyThread();
  
  //给线程设置名称
  mt1.setName("窗口一");
  mt2.setName("窗口二");
  mt3.setName("窗口三");
  
  //启动线程，开启售票
  mt1.start();
  mt2.start();
  mt3.start();
  
 }

}
package com.edu_10;
/**
 *   C:锁对象问题
   a:同步代码块（定义一个抽象类，里面专门定义一个锁）
    任意对象
   
   b:同步方法（仅适用于实现runable接口）
   public synchronized void sellTicket(){同步代码}
    this
   
   c:静态同步方法
    类的字节码对象
    public static synchronized void sellTicket() {
      需要同步的代码
    }
 *
 */
public class MyThread implements Runnable{
 //定义100张票
 static int ticket = 100;
 Object obj = new Object();
 int x = 0;
 
 @Override
 public void run() {
  while (true) {
   if (x%2==0) {
    synchronized (MyThread.class) {//这样3个线程才可以共享同一把锁 
     if (ticket>0) {
       //考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
       try {
        Thread.sleep(100);
       } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
       }
       
       System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
      }
     }
   }else {
    sellTicket(); 
   }
   x++;
  }
  
 }

 private void sellTicket() {
  synchronized (obj) {//这样3个线程才可以共享同一把锁 
   if (ticket>0) {
     //考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
}     
     System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
    }
   }
 }
 
 
 //同步方法：同步方法是将synchronized关键字加到方法上,同步方法的锁是this
 private synchronized void sellTicket() { 
  if (ticket>0) {

//考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
    try {
     Thread.sleep(100);
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
    
   System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
   
  }
 }
 
 
 //静态同步方法,他的锁是本类的字节码文件对象：类名.class。
 private static synchronized void sellTicket() { 
 if (ticket>0) {
   //考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   
   System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
  
 }
}

}