Java语言高级第八天

线程

多线程原理

自定义线程类：

  public class MyThread extends Thread{
/*    
 * 利用继承中的特点     
 *   将线程名称传递  进行设置    
 */    
public MyThread(String name){    
super(name);        
}    
/*    
 * 重写run方法    
 *  定义线程要执行的代码    
 */    
public void run(){           
for (int i = 0; i < 20; i++) {
方法 来自父亲            
System.out.println(getName()+i);            
}        
}    
}

测试类

public class Demo {
    public static void main(String[] args) {
       System.out.println("这里是main线程");  
     MyThread mt = new MyThread("小强");            
     mt.start();//开启了一个新的线程    
     for (int i = 0; i < 20; i++) {    
System.out.println("旺财:"+i);            
}        
}    
} 

Thread 类

构造方法：

public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

常用方法：
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

创建线程方式

步骤如下：
1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
的线程对象。
3. 调用线程对象的start()方法来启动线程。

public class MyRunnable implements Runnable{
@Override    
public void run() {    
for (int i = 0; i < 20; i++) {        
System.out.println(Thread.currentThread().getName()+" "+i);            
              }        
       }    
 }

public class Demo {
    public static void main(String[] args) {
        //创建自定义类对象  线程任务对象
        MyRunnable mr = new MyRunnable();
        //创建线程对象
        Thread t = new Thread(mr, "小强");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财 " + i);
        }
    }
}

Thread 和Runnable的区别

实现Runnable接口比继承Thread类所具有的优势：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

匿名内部类方式实现线程的创建

  public class NoNameInnerClassThread {
   public static void main(String[] args) {            
// new Runnable(){      
// public void run(){          
// for (int i = 0; i < 20; i++) {              
// System.out.println("张宇:"+i);                  
// }              
// }            
//    }; //‐‐‐这个整体  相当于new MyRunnable()    
        Runnable r = new Runnable(){
            public void run(){
                for (int i = 0; i < 20; i++) {
                   System.out.println("张宇:"+i);  
                }
            } 
        };
        new Thread(r).start();
for (int i = 0; i < 20; i++) {
           System.out.println("费玉清:"+i);  
        }
   } 
}

线程安全

我们通过一个案例，演示线程的安全问题：
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个
(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)
需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

结果中有一部分这样现象：

 发现程序出现了两个问题：
1. 相同的票数,比如5这张票被卖了两回。
2. 不存在的票，比如0票与-1票，是不存在的。
这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

线程同步

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。

1 . 同步代码块。
2. 同步方法。
3. 锁机制。

同步代码块

同步代码块 ： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式:

synchronized(同步锁){
     需要同步操作的代码
}

 同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
1. 锁对象 可以是任意类型。
2. 多个线程对象 要使用同一把锁。

同步方法

同步方法 :使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式：

public synchronized void method(){
   可能会产生线程安全问题的代码 
}

 对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

Lock 锁

Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock() :加同步锁。
public void unlock() :释放同步锁。

public class Ticket implements Runnable{
private int ticket = 100;    
   
Lock lock = new ReentrantLock();    
/*    
 * 执行卖票操作    
 */    
@Override    
public void run() {    
//每个窗口卖票的操作         
//窗口 永远开启         
while(true){        
lock.lock();            
if(ticket>0){//有票 可以卖            
//出票操作                 
//使用sleep模拟一下出票时间                 
try {                
Thread.sleep(50);                    
} catch (InterruptedException e) {                
// TODO Auto‐generated catch block                    
e.printStackTrace();                    
}                
//获取当前线程对象的名字                 
String name = Thread.currentThread().getName();                
System.out.println(name+"正在卖:"+ticket‐‐);                
}            
lock.unlock();            
}        
}    
}