javaSE-多线程学习

一、Java多线程实现的方式有四种

1.继承Thread类，重写run方法

public class ThreadDemo01 extends Thread{
      public void run(){
        //编写自己的线程代码
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args){ 
        new ThreadDemo01("我是自定义的线程").start();       
    }
}

2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target

public class ThreadDemo02 {

  public static void main(String[] args){ 
        System.out.println(Thread.currentThread().getName());
        Thread(new MyThread()).start(); 
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式！");
    }   
}

3.通过Callable和FutureTask创建线程

public class CallableTest {

    public static void main(String[] args) throws Exception {

      //实现Callable接口的call()方法，传入返回参数类型
        Callable<Integer> c = new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 100; i++) {
                    sum += i;
                    System.out.println(Thread.currentThread().getName() + i);
                }
                return sum;
            }
        };

     // FutureTask<V> implements RunnableFuture<V>==》 RunnableFuture<V> extends Runnable, Future<V>        

        FutureTask<Integer> f = new FutureTask<>(c);
        new Thread(f).start();
        System.out.println(f.get());//获取返回结果

           }

}

4.通过线程池创建线程

public class CallableTest {

    public static void main(String[] args) throws Exception {
        Callable<Integer> c = new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 100; i++) {
                    sum += i;
                    System.out.println(Thread.currentThread().getName() + i);
                }
                return sum;
            }
        };

        // 线程池启动线程
        ExecutorService ex = Executors.newFixedThreadPool(1);
        ex.submit(f);//提交线程
        System.out.println(f.get());//获取返回值
        ex.shutdown();//关闭线程

    }

}

 

二、java线程常用的方法

//当前线程可转让cpu控制权，让别的就绪状态线程运行（切换）
public static Thread.yield() 

//暂停一段时间，常用于模拟网络延时
public static Thread.sleep()  

//在一个线程中调用other.join(),将等待other执行完后才继续本线程。　　　　
public join()

//后两个函数皆可以被打断
public interrupte()

 

三、常用的方法

        // 常用方法
        Thread thread = new Thread();
        thread.setName("name");// 设置线程名
        thread.getName();// 获取线程名
        thread.isAlive();// 查看线程是否存活
        // 设置优先级，优先级越大，执行的概率越大，不是绝对的的先后顺序
        thread.setPriority(Thread.MAX_PRIORITY);

四、并发问题

当多个线程访问同一块资源时，就会产生并发问题。常用的解决并发问题的方法有：

1.synchronized 同步锁(隐式锁)

（1）同步锁修饰的资源时，当一个线程获取锁时，会阻塞其他线程对此资源的访问，直至当前线程访问完成后释放锁，下一个线程才能访问。

（2）synchronized  修饰代码块时，synchronized块中的方法获取了lock实例的monitor，如果实例相同，那么只有一个线程能执行该块内容

       synchronized(lock){
         //代码
       }

（3）synchronized修饰方法

  public synchronized void method()

  {  // todo

  }

（4）synchronized修饰静态方法，synchronized修饰的静态方法锁定的是这个类的所有对象

public  synchronized  static void method()

  {  // todo

  }

（5）synchronized修饰一个类，synchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁。

 （6）总结：

A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

2.wait()、notify/notifyAll() 三者的区别：

1、wait()、notify/notifyAll() 方法是Object的本地final方法，无法被重写。

2、wait()使当前线程阻塞，前提是 必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。

3、 由于 wait()、notify/notifyAll() 在synchronized 代码块执行，说明当前线程一定是获取了锁的。当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。也就是说，notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。所以在编程中，尽量在使用了notify/notifyAll() 后立即退出临界区，以唤醒其他线程 

4、wait() 需要被try catch包围，中断也可以使wait等待的线程唤醒。

5、notify 和wait 的顺序不能错，如果A线程先执行notify方法，B线程在执行wait方法，那么B线程是无法被唤醒的。

6、notify 和 notifyAll的区别

notify方法只唤醒一个等待（对象的）线程并使该线程开始执行。所以如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程，选择哪个线程取决于操作系统对多线程管理的实现。notifyAll 会唤醒所有等待(对象的)线程，尽管哪一个线程将会第一个处理取决于操作系统的实现。如果当前情况下有多个线程需要被唤醒，推荐使用notifyAll 方法。比如在生产者-消费者里面的使用，每次都需要唤醒所有的消费者或是生产者，以判断程序是否可以继续往下执行。

3.volatile

多线程的内存模型：main memory（主存）、working memory（线程栈），在处理数据时，线程会把值从主存load到本地栈，完成操作后再save回去(volatile关键词的作用：每次针对该变量的操作都激发一次load and save)。本质上，volatile就是不去缓存，直接取值。在线程安全的情况下加volatile会牺牲性能。

4.lock（显示锁）

（1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性，是在JVM层面上实现的,如果代码执行出现异常,JVM会自动释放锁。Lock是一个类，通过这个类可以实现同步访问,就必须将unLock放到finally{}中(手动释放);；

.ReentrantLock增加了锁:

　　　　a. void lock(); // 无条件的锁;

　　　　b. void lockInterruptibly throws InterruptedException;//可中断的锁;解释:使用ReentrantLock如果获取了锁立即返回,如果没有获取锁,当前线程处于休眠状态,直到获得锁或者当前线程可以被别的线程中断去做其他的事情;但是如果是synchronized的话,如果没有获取到锁,则会一直等待下去;

　　　　c. boolean tryLock();//如果获取了锁立即返回true,如果别的线程正持有,立即返回false,不会等待;

　　　　d. boolean tryLock(long timeout,TimeUnit unit);//如果获取了锁立即返回true,如果别的线程正持有锁,会等待参数给的时间,在等待的过程中,如果获取锁,则返回true,如果等待超时,返回false;

Lock lock = new ReentrantLock();

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

Condition的特性:

　　　　1.Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的这些方法是和同步锁捆绑使用的；而Condition是需要与互斥锁/共享锁捆绑使用的。

　　　　2.Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。
　　　　例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒"读线程"；当从缓冲区读出数据之后，唤醒"写线程"；并且当缓冲区满的时候，"写线程"需要等待；当缓冲区为空时，"读线程"需要等待。      

　　　　  如果采用Object类中的wait(), notify(), notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒"读线程"时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程"，而只能通过notifyAll唤醒所有线程(但是notifyAll无法区分唤醒的线程是读线程，还是写线程)。  但是，通过Condition，就能明确的指定唤醒读线程。

Condition condition = lock.newCondition();

lcondition.await();

 

5.死锁

死锁是两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。例如，如果线程1锁住了A，然后尝试对B进行加锁，同时线程2已经锁住了B，接着尝试对A进行加锁，这时死锁就发生了。线程1永远得不到B，线程2也永远得不到A，并且它们永远也不会知道发生了这样的事情。为了得到彼此的对象（A和B），它们将永远阻塞下去。这种情况就是一个死锁。

解决死锁一般有如下方法：

1)尽量使用tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock)，设置超时时间，超时可以退出防止死锁。 
2)尽量使用java.util.concurrent(jdk 1.5以上)包的并发类代替手写控制并发，比较常用的是ConcurrentHashMap、ConcurrentLinkedQueue、AtomicBoolean等等，实际应用中java.util.concurrent.atomic十分有用，简单方便且效率比使用Lock更高 
3)尽量降低锁的使用粒度，尽量不要几个功能用同一把锁 
4)尽量减少同步的代码块

五、相关知识

1.Timer 定时器

//定时器
        Timer timer=new Timer();
        //定时计划，TimerTask定时器任务
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                //执行的任务代码
                System.out.println("执行任务！");
            }
            //立即执行任务，间隔时间2秒
        }, new Date(), 2000);

2.spring 及spring boot自带定时任务