线程

线程用到的类和接口

线程用到的类有Thread，接口为Runnable

线程的启动

方法1：

public class ff extends Thread{
        public void run(){
            System.out.println("线程启动成功！");
        }
        public static void main(String[] args) {
            new ff().start();
        }
}

方法二：

public class ff implements Runnable{
        public void run(){
            System.out.println("线程启动成功！");
        }
        public static void main(String[] args) {
            new Thread(new ff()).start();
        }
}

线程中常用的方法：

1）Sleep(millis);用于暂定线程，将资源让给其他线程；也可Object.Sleep()或Thread.Sleep();

2)yield();用于当前线程资源的释放，然后从新重处理器那里争夺资源

3）jion();使当前线程运行完毕后才能将资源释放。

关键字

volatile：修饰变量，使变量具备可见性（一个线程改变该变量时，另一线程能准确读到最新值）。

synchronized：可修饰函数或单独形成代码块

只要本次的同步代码块中的代码没有执行完，其它线程无法进入，因为锁没有释放

synchronized（this）{

代码、、、、、、
}

1 public synchronized void run(){ 

2 代码、、、、、
3 
4 }

 线程实例：

 隋唐演义中的军队类
 1 package st;

public class jd implements Runnable {
volatile boolean wordkeeping=true;
    public void run() {
         while(wordkeeping){
             for (int i=0;i<5;i++) {
             System.out.println(Thread.currentThread().getName()+"击打了敌军"+i+"次");
             try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             Thread.yield();
             }
            
         }   
    }
}

package st;
/*
 * 程咬金
 * 
 * */
public class Mrcheng implements Runnable{

    @Override
    public void run() {
        System.out.println("半路杀出个程咬金！");
        for(int i=0;i<10;i++){
        System.out.println(Thread.currentThread().getName()+"发出第"+i+"次攻击");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
           }
        System.out.println("Mr.Cheng结束战斗！");
        }
    
    }

package st;
/*
 * 舞台
 * */
public class stage implements Runnable {

    @Override
    public void run() {
        System.out.println("隋唐演义即将开始！");
        jd f=new jd();
        jd f1=new jd();
        Thread a=new Thread(f,"隋军");
        Thread b=new Thread(f1,"农民起义军");
        
        a.start();
        
        b.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        f.wordkeeping=false;//线程的结束方法
        f1.wordkeeping=false;
      System.out.println("战斗结束！");  
        Thread c=new Thread(new Mrcheng(),"程咬金");
        c.start();
        try {
            c.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("程先生完成了他的光荣使命，包围了世界和平！");
        System.out.println("谢谢大家的观看，战斗完毕！");
        
    }
public static void main(String[] args) {
        Thread d=new Thread(new stage());
        d.start();
}
}

 线程的停止方法：

错误的停止方法：Storp（）；

应使用停止标志；如上列中的wrodkeeping就是停止标志。

 

线程的互斥、同步 

互斥：

Java对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对synchronized关键字的作用进行深入了解才可定论。
　　总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。
　　在进一步阐述之前，我们需要明确几点：
　　A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
　　B．每个对象只有一个锁（lock）与之相关联。
　　C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
　　接着来讨论synchronized用到不同地方对代码产生的影响：
　　假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。

　　1． 把synchronized当作函数修饰符时，示例代码如下：
　　Public synchronized void methodAAA()
　　{
　　//….
　　}
　　这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。
　　上边的示例代码等同于如下代码：
　　public void methodAAA()
　　{
　　synchronized (this) // (1)
　　{
　　 //…..
　　}
　　}
　　(1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（
　　2．同步块，示例代码如下：
　　 public void method3(SomeObject so)
　　 {
　　 synchronized(so)
　　{
　　 //…..
　　}
　　}
　　这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：
　　class Foo implements Runnable
　　{
　　 private byte[] lock = new byte[0]; // 特殊的instance变量
　　 Public void methodA()
　　{
　　 synchronized(lock) { //… }
　　}
　　//…..
　　}
　　注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

 同步：

public class hctbDemo implements Runnable {
final    //Object mutex =new Object();    
byte[] mutex=new byte[0];
    public void run() {
        synchronized (mutex) { //
            try {
                mutex.wait();//等待状态，直到被其他线程唤醒
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }  
            mutex.notifyAll();//唤醒等待中的全部线程
        }    
    }
}