Runnable接口实现线程、synchronized块锁代码详解

线程：
1、利用Runnable接口实现线程
· 这种方式扩展性较强，可以实现一个接口，还可以再去继承其他类，省去了单继承的弊端；但这种方式也要重写run方法，实现该接口后与Thread类一起使用。
· 实现了Runnable接口的类的对象不是线程对象，只是为线程对象提供入口方法（run()方法）。
· 创建了实现Runnable接口的类的对象后，可以直接new一个线程对象（Thread t = new Thread(mt)）（有自己的run方法，只是不用），注意要调用Thread类有参的构造方法，将实现了Runnable的类的对象的地址作为参数传给线程对象。

 注：用这种方法创建的线程对象，一旦虚拟机调用线程对象占用处理机，马上就会调用实参所指的实现了Runnable的类的对象的run方法。

2、

synchronized  块锁（灵活）   语句块同步
         格式：
            Synchronized(对象){    //对象锁
需要同步的代码;  //临界资源不能中断的代码
}

① //该对象就是一把锁/监视器，监视进程的进出,若有线程进入会先判断同步块的锁是否开启，若没有开启，那么后来的线程就会进入该对象的锁池等待（处于锁池的线程处于阻塞态）；当当前线程执行完同步代码块，锁就会开启，此时锁池的线程就会进入就绪态，等待争用处理机
② // 这个对象要定义为静态成员变量，才能被所有线程共享；不能在里面new对象，会导致每把锁都不一样，锁就没有了意义
③ 任何对象锁

3、synchronized 方法锁（实例方法） 实现同步
① 实际上在锁调用该方法的对象（地址）(this所指对象)
② this所指对象调用的用synchronized标记的方法都会被锁住
// 访问权限 synchronized 返回类型 方法名（）{方法体}

4、synchronized 类锁：
① 在代码中的方法上增加static synchronized 的锁
（静态方法由类调用，它锁的是静态方法所对应的类
对应的反射对象）。
② synchronized(xxx.class) 代码段

5、私有锁：
在类内部声明一个私有属性如private Lock lock,在需要加锁的地方使用synchronized(lock)
14-2 -ThreadTest.java

public class ThreadTest{
    public static void main(String[] args){
        ThreadDemo tt = new ThreadDemo();
        Thread t = new Thread(tt);//启用tt对象的run（）方法//t线程有自己的run方法，只是不调用//主线程也可能执行完这步时间片就到了
        t.start();
        try{
            Thread.currentThread().sleep(5000);//当前线程主线程睡眠5000毫秒；t线程占用处理机，调用其实参所指对象tt的run()方法。
                //boolean b=t.isAlive();//判断t线程是否还活着
			    //System.out.println("t isAlive(): "+ b);
			  
				// t.stop(); //t线程睡眠，主线程醒来执行这句代码，强行终止睡眠中的t线程。  //不提倡使用这种方法终止线程
				//若t线程在执行一个不可分割的原子操作时睡着了，没加锁，主线程调用t线程stop方法，会破坏原子性。
			    
	//提倡使用这种方法终止线程		//t.interrupt(); //主线程醒来强行唤醒t线程（此时可能输出完4个love，时间片轮转让结果变得不能确定），t线程从阻塞态进入就绪态，抛出异常，执行catch块，线程终止。
				 //也有可能主线程还没执行这句代码时间片就到了，进入阻塞态；t线程睡醒……
			  
			   tt.stopRunning();//t线程输出了四次love，睡第五次时；主线程苏醒，调用tt所指对象的stopRunning,将tt所指对象的flag属性的值改成false，
				//主线程执行完死亡；t线程醒来，再输出第五个love；发现flag变成了false，终止循环，死亡。（时间片不定，所以love输出几次结果不定）
        }
        catch(InterruptedException e){
            System.out.println(e);
        }
    }
}
class ThreadDemo implements Runnable{
    boolean flag = true;  //共享
    public void stopRunning(){
        this.flag = false;
    }
    public void run(){
        System.out.println("falg = " + this.flag);
        while(flag){
            try{
                Thread.currentThread().sleep(1000);
            }
            catch(InterruptedException e){
                System.out.println("线程被终止");
             return;
			}
            System.out.println("I love you");//
        }
    }
}

堆排序：先建堆（大顶堆或小顶堆）把堆顶元素和末尾元素进行交换，数组最后一个数肯定就是最大或者最小的，固定。最后又在剩下的数据里面建大/小顶堆，再交换。 要注意的是升序建大堆，降序建小堆。
代码：

public class heapSort {
   //堆调整//升序大顶堆、降序小顶堆
	/*
	 * arr--待调整数组
	 * i--非叶子结点
	 * length--等待调整的长度
	 */
	public void adjustHeap(int []arr,int i,int length){
		int temp=arr[i];
		for(int k=i*2+1;k<length;k=k*2+1){
			if(k+1<length && arr[k]<arr[k+1]){ //左结点小于右结点
				k++;//k指向较大的右子结点
			}
		//将已经调整过的左结点和非叶子结点作比较
			if(arr[k]>temp){//子结点大于父节点
				arr[i]=arr[k];//将较大的值放到当前非叶子结点的位置
				i=k;//i指向k，向下遍历，左子结点下面可能还有子结点
			}else{
				break;
			}
		}
		//调整过的非叶子结点  // 此时已经是局部大顶堆
		arr[i]=temp;//将temp的值放到调整后的位置
	}
	//构成大顶堆，开始将堆顶元素和末尾元素交换
	public void heapsort(int []arr){
		int temp=0;
		//将局部大顶堆调整成完全大顶堆
       //非叶子结点索引：i=arr.length/2-1
		for(int i=arr.length/2-1;i>=0;i--){
			adjustHeap(arr,i,arr.length);
		}
		//将堆顶元素和末尾元素进行交换
		for(int j=arr.length-1;j>0;j--){
			temp=arr[j];
			arr[j]=arr[0];
			arr[0]=temp;
			adjustHeap(arr,0,j);//交换完继续调整、交换--交替
		}
	}