多线程总结

多线程总结

1.多线程的实现:

1. 方法一 : 继承类: Thread 让定义的类通过extends Thread类来实现多线程.
2. 方法二 : 实现接口: Runnable 让定义的类通过implment Runnalble来实现多线程.
3. 由于java语言特性 , 只允许单继承,所以只能继承Thread类 , 但是可以实现多接口啊,所以首选方法就是方法二是比较好的.
4. Thread中的方法比较多,首先就是所需任务必须通过覆写run方法,其次就是start , sleep(休眠需要配合 try catch使用) , join(用来执完当前线程再去申请结束下一个线程).
5. 申请线程时可以直接使用线程池来申请

(ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT))

thread代码demo

    package collection.concurrency.multithread;
    
    public class Runner {
        public static void main(String[] args) {
            Thread t1 = new Thread(new BasicRunnable(),"t1");
            Thread t2 = new Thread(new BasicRunnable(),"t2");
            System.out.println("APP Start " + Thread.currentThread().getName());
            System.out.println("starting runnble threads");
            t1.start();
            t2.start();
            System.out.println("runnble threads has started");
        Thread t3 =new BasicThread("t3");
        Thread t4 =new BasicThread("t4");
        t3.start();
        t4.start();
        System.out.println("All runnble threads has started");
    }
}

    package collection.concurrency.multithread;
    
    public class BasicThread extends Thread {
        public BasicThread(String name) {
            super(name);
        }

    @Override
    public void run() {
        System.out.println("RUNNING START" + Thread.currentThread().getName()); //currentthread为主线程
        try {
            Thread.sleep(1000);
            Processing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("RUNNABLE END" + Thread.currentThread().getName());

    }

    private void Processing() throws InterruptedException {
        System.out.println("PROCESSING....");
        Thread.sleep(5000);
    }

}

1.死锁问题

• 个人理解 : 就是由于多线程的原因 , 操作同一对象时会产生冲突 , 譬如 : 两个人玩两块积木时 , 各自都持有不同的并且还都想要对方手上的积木 , 此时死锁产生 , 如果不解决此问题的话程序会产生错误.

• 解决方法 : 此时就需要在编程时加上 synchronized , 可以在对象上加,也可以在方法上加

  `package collection.concurrency.multithread;

  static BasicMethodSync instance = new BasicMethodSync();
   static int i = 0;
  
   /*private static synchronized void increase(){
       i++;
   }*/
   private static synchronized void increase(){
       i++;
   }
  
   @Override
   public void run() {
       for (int j = 0;j < 2000000;j++){
           increase();
       }
   }
  
   public static void main(String[] args) throws InterruptedException {
       Thread t1 = new Thread(new BasicMethodSync());
       Thread t2 = new Thread(new BasicMethodSync());
       Thread t3 = new Thread(new BasicMethodSync());
       long prev = System.currentTimeMillis();
       t1.start();
       t2.start();
       t3.start();
       t1.join();
       t2.join();
       t3.join();
       long cyr = System.currentTimeMillis();
       //  System.out.println(i);
       System.out.println("Final result: " + i);
       System.out.println("Time used " + (cyr - prev));
   }
  

  }

`

• 解决方法二 : lock方法,只需要先 public static ReentrantLock lock = new ReentrantLock(); . 在具体代码中使用时

   lock.lock;
   try {
       i++;
   }
   finally {
       lock.unlock();
   }
  

将申请的lock在使用前加上lock锁上就可以,执行完再unlock解锁就行了 , 还有中stampslock , 这种使用起来比这种话reentrantlock更功能强大.