浅谈Java多线程

Java中多线程涉及下面4点

1. 创建单线程：继承Tread类 和 实现Rannable接口；
2. 多线程使用：手动实例化多个线程 或者 使用线程池 ExecutorService；
3. 多线程共享数据同步：可以采用同步synchronized执行run方法中的操作；
4. 合理使用多线程同步数据，防止死锁问题。

1.创建线程

1. 继承Tread类
   

   public class MyThread extends Thread {
       
       public void run() {
           System.out.println(Thread.currentThread().getName());
       }
       
       public static void main(String[] args) {
           //不能共享数据
           //MyThread myThread = new MyThread(); 
           //能共享数据
           Thread myThread = new Thread(new MyThread());
           myThread.start(); 
       }
   }

2. 实现Rannable接口

   public class MyThread implements Runnable {
       
       public void run() {
           System.out.println(Thread.currentThread().getName());
       }
       
       public static void main(String[] args) {
           //能共享数据
           Thread  myThread = new Thread(new MyThread());   
           myThread.start();
       }
   }

   上面写了两种创建线程的例子，注意：注释内容。

2.多线程使用

1.  手动实例化自定义的线程类
   

   public class MyThread implements Runnable {
       
       public void run() {
           System.out.println(Thread.currentThread().getName());
       }
       
       public static void main(String[] args) {
           MyThread myThread  = new MyThread();
           new Thread(myThread).start();
           new Thread(myThread).start();
           new Thread(myThread).start();
       }
   }

2. 使用线程池 ExecutorService

   public class MyThread implements Runnable {
       
       public void run() {
           System.out.println(Thread.currentThread().getName());
       }
       
       public static void main(String[] args) {
           ExecutorService pool = Executors.newCachedThreadPool();
           MyThread myThread = new MyThread();
           for(int i = 0; i < 3; i++){
               pool.execute(myThread);
           }
           //关闭线程池
           pool.shutdown();
       }
   }

3.多线程共享数据同步

一个简单卖票代码：3个卖票员，共卖100张门票，买一张票耗时100毫秒。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThread implements Runnable {

    private int tickets = 100;

    private synchronized void sale() {
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + " 剩余："
                    + (--tickets) + "张票");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else{
            Thread.currentThread().stop();
        }
    }

    public void run() {
        while(true){
            sale();            
        }
    }

    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        MyThread myThread = new MyThread();
        for (int i = 0; i < 3; i++) {
            pool.execute(myThread);
        }
        pool.shutdown();
    }

}

4.死锁

当线程之间互相等待共享资源时，会产生死锁问题。我们可以在多线程的程序中减少同步关键字的使用，减少每一次占用资源的时间之类的措施来降低死锁出现的可能性。