Java并行程序基础。

 

线程的基本操作：

　　1、创建线程：只需要new一个线程对象即可：thread mythread=new thread()。然后 mythread.start() 即可开启线程。那么问题来了，这个线程到底要做些什么呢，所以，thread有一个run() 方法，方法体则是线程要做的事情。而默认情况下，run（）方法什么不做，所以我们需要重写run（），把你要做的事情填进去。

 public static void main(string[] args) {
        thread t1=new thread(){
            @override
            public void run() {
                system.out.println("hello i am t1");
            }
        };
        t1.start();
    }

　　上面使用匿名内部类的方式重写了run方法。

　　因为java是单继承的，有时候继承也是一种稀缺的资源，所以可以用runable接口来实现：

public interface runnable{
        public  abstract void  run();
    }

　　runnable接口就只有一个run方法。

　　thread类还有一个重要的构造方法：public thread (runnable target) ，所以，可以通过实现了runnable接口的类的实力来创建线程，同时，runnable是一个函数式接口，所以还可以使用lambda表达式：

public static void main(string[] args) {
        thread t1=new thread(()-> system.out.println("hello i am t1"));
        t1.start();
    }

　　2、终止线程：thread.stop() 可以终止线程，但是它是一个废弃的方法，因为它太过暴力，即使线程正在执行中，也会直接终止，并释放锁。

　　3、线程中断：线程中断不会使线程立即退出，而是给线程发送一个通知，告诉目标线程：有人希望你退出啦！至于目标线程如何处理，还是又目标线程自己决定。

　　　　　　　　有关线程中断的三个方法：thread.interrupt() 中断线程。thread.isinterruputed() 判断是否被中断了。 thread.interrupted() 判读是否被中断，并且清除中断状态。

 public static void main(string[] args) throws interruptedexception {
        thread t=new thread(){
            @override
            public void run() {
                while (true)
                    system.out.println("t1 is running.");
            }
        };
        t.start();
        thread.sleep(1000);
        t.interrupt();
    }

　　　　上面代码中，对线程t进行了中断，但并没有作出中断后的操作，所以是没有效果的。改进：

public static void main(string[] args) throws interruptedexception {
        thread t=new thread(){
            @override
            public void run() {
                while (true){
                    if (thread.currentthread().isinterrupted())
                        break;
                    system.out.println("t1 is running.");
                }
            }
        };
        t.start();
        thread.sleep(1000);
        t.interrupt();
    }

　　4、等待（wait）和通知（notify）：为了支持多线程之间的协作，jdk提供了wait（）和notify（），这两个方法并不在thread类中，而是在object中，也就是说，任何对象都可以调用这两个方法。

　　　　当线程a 调用了obj.wait()方法后，线程a就会停止执行，转为等待状态。等待的状态要等到其他线程调用obj.notify()方法为止。

　　　　当某个线程调用了object.wait()方法后，该线程就会进去object对象的等待队列。这个等待队列中，可能有多个线程。当调用 object.notify()时，会随机在队列中唤醒一个线程。而调用object.notifyall()时，会唤醒所有线程。

　　　　注意：wait()和notify（）都必须在synchronized语句中，必须先获得目标对象的监听器，才能调用这两个方法。调用wait后，会释放监听器。

　　5、挂起（suspend）和继续执行（resume）：suspend可以停止线程执行，直到resume。但suspend停止时，不会释放资源，所以不推荐使用。

　　6、等待线程结束（join）和谦让（yeild）：线程之间协作时，有时会有先后关系，也就是b线程等到a线程执行完了，再执行。

volatile：

　　当用volatile关键字申明变量时，就等于告诉虚拟机，这个变量极有可能会被某些线程修改，虚拟机就会做一些操作，来确保这个变量背修改后，应用程序范围内的所有线程都能看到这个改动。用volatile申明的变量可以保证有序性和可见性，但无法保证原子性。

守护线程：

　　守护线程是一种特殊的线程，它是系统的守护者，在后台完成一些系统性的服务，比如垃圾回收线程。与之对应的是用户线程。当一个java应用只有守护线程时，java虚拟机就会自然退出。setdaemon（）可以将线程设为守护线程。

public class test {
  public static class daemonthread extends thread{
      @override
      public void run() {
          while (true){
              system.out.println("i am alive");
          }
      }
  }

    public static void main(string[] args) throws interruptedexception {
        thread thread=new daemonthread();
        thread.setdaemon(true);
        thread.start();
        thread.sleep(2000);
    }
}

　　将thread设置为守护线程，所以在主线程休眠2s后，用户线程全部结束，整个程序也就结束了。

线程优先级：

　　优先级高的线程在竞争资源时，会更有优势。但是这只是概率问题，运气不好的话，高优先级的线程也可能抢占资源失败。setpriority（）来设置线程优先级。

public class test {
    final static object obj=new object();
    public static class low extends thread{
        static int i=0;
        @override
        public void run() {
            while (true){
                synchronized (obj){
                    i++;
                    if (i>100000){
                        system.out.println("low complete。");
                        break;
                    }
                }
            }
        }
    }
    public static class high extends thread{
        static int i;
        @override
        public void run() {
            while (true){
                synchronized (obj){
                    i++;
                    if (i>150000){
                        system.out.println("high complete.");
                        break;
                    }
                }
            }
        }
    }

    public static void main(string[] args) {
        thread low=new low();
        thread high=new high();
        low.setpriority(thread.min_priority);
        high.setpriority(thread.max_priority);
        low.start();
        high.start();
    }

}

　　上述代码中，即使high要多加50000次，但是因为优先级高，会更先执行完。

synchronized：

　　关键字synchronized的作用是实现线程间的同步。它的工作是对同步的代码加锁，使得每一次只有一个线程进入同步快，从而保证线程间的安全性。

　　用法：可以给指定对象加锁（上面事例中），也可以作用于实例方法：

public class test implements runnable {
    static test t=new test();
    static int i=0;
        public synchronized void add(){
            i++;
        }

        @override
        public void run() {
            for (int k=0;k<100000;k++)
                add();
        }

    public static void main(string[] args) throws interruptedexception {
        thread t1=new thread(t);
        thread t2=new thread(t);
        t1.start();
        t2.start();
        t1.join();t2.join();
        system.out.println(i);
    }
}