Java基础（线程问题）

**

1. 线程和进程分别是什么？

一个任务就是一个程序，每个运行的程序就是一个进程，当一个程序运行，内部包含了多个执行顺序，这个顺序流就是线程。

• **

**2. 线程创建的三种方式

**

**

2.1基础Thread类，来创建线程**

package practice1;

public class ThreadCreat extends Thread {
    public void run(){
        System.out.println(Thread.currentThread().getName()+"启动");
    }

    public static void main(String[] args) {
        ThreadCreat t=new ThreadCreat();
        Thread t1=new Thread(t,"线程名称");
        t1.start();
    }

}

2.2：调用Runnable接口来实现线程的创建：

package practice1;

public class ThreadCreat1 implements  Runnable {
    public void run(){
        System.out.println(Thread.currentThread().getName()+"创建");
    }

    public static void main(String[] args) {
        ThreadCreat1 t=new ThreadCreat1();
        Thread t1=new Thread(t,"线程名称");
        t1.start();
    }
}

2.3：使用Runnable接口增强版 Callable接口结合Future类一起实现

package practice1;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class ThreadCreat3 implements Callable {
    @Override
    public Object call() throws Exception {
        return "线程结束了哦";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadCreat3 t=new ThreadCreat3();
        FutureTask f=new FutureTask(t);
        Thread tt=new Thread(f);
        tt.start();
        System.out.println(f.get());
    }
}

三种方式创建线程的三种方式的对比：

**优点：**线程实现Runnable接口或者是Callable接口时，还可以继承其他的类。
缺点是：遇到复杂的代码编写，如果需要获得当前线程的名字是，需要Thread.cerrentThread().getName()

**使用Thread类优点：**代码编写简答，如果获得当前线程对象时，只需要this指向就可以了
缺点：Java中是单继承，只能继承一个类。

启动线程需要使用start方法

永远不要调用线程的run方法，调用start方法启动线程，系统会默认把run方法当成线程的执行体，如果调用run方法，run方法会被立即执行，而且在run方法返回之前其他线程无法并发执行，系统会把run方法当初一个普通的方法，而不是线程的执行体。

线程的常用方法：

join：使调用者插入，必须要等调用者结束了，其他的线程才会继续执行
setDaemon（boolean a）：守护线程，这个线程在别的线程中，当别的线程执行完毕，这个线程的调用线程必须陪着 别的线程一起死亡。
sleep：线程睡眠
yield：与sleep方法类似，但是不会阻塞该线程，只是将线程转换为就绪状态，yield是让这个线程暂停一下，实际上，当某个线程调用了yield方法暂停，只有优先级与当前线程相同时，或者优先级比当前优先级更高的就绪状态的线程才会获得执行的机会。
setPority（）设置线程的优先级

线程的安全问题：

这里涉及到一个著名的问题，银行家算法，如果一个账户多人进行取钱，很有可能A用户取完钱时，还没有来得及打印输出，这个A用户的亲戚B用户进行取钱操作（线程二），等线程二执行到打印时，A用户的打印又重新开始执行，这是数据就发生了错乱，为了解决这个问题，我们需要设置的安全性。因为线程的执行时随机的，我们需要让一个线程先执行完，在继续执行另一个线程。（也就是A先正常取一次钱，然后打印输出余额。然后B再继续取钱。依次有序的执行）这便是线程的安全问题：
为了解决这个问题：我们引入移同步监视器来解决这个问题，使用的是同步代码块：
synchronized（obj）{ //同步代码块 }
同步监视器的目的：就是为了阻止两个线程对一个共享资源的并发访问，我们一般将这个共享资源当作同步监视器，在银行中，也就是账户设置为同步代码块。
我们就需要将需要按照顺序执行的代码，放在同步代码块的位置上。按照银行的例子来说的话，我们需要将取钱，打印的步骤放在run方法中，然后使用同步代码块。例如：

    public void run(){
        for(int i=0;i<5;i++) {
            synchronized(acount){
                if (acount.getMoeny() >= 100) {
                    acount.setMoeny(acount.getMoeny()-100);
                    System.out.println(Thread.currentThread().getName()+"取走100元剩余"+acount.getMoeny());
                }else{
                    System.out.println("钱不够"+Thread.currentThread().getName()+"取钱失败");
                }
            }
        }
    }

与同步代码块对应的是同步方法：

我们就可以在 账户这个类中加入同步方法

  public synchronized void synchronizedGetmoney(){
        if (this.getMoeny() >= 100) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setMoeny(this.getMoeny()-100);
            System.out.println(Thread.currentThread().getName()+"取走100元剩余"+this.getMoeny());
        }else{
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("钱不够"+Thread.currentThread().getName()+"取钱失败");
        }
    }
}
 

当然我们也可以自己手动加入同步锁：

也就是可以自己手动的锁住当前线程，不允许其他线程打扰，使用完后就可以手动解锁，让其他线程使用，有点像上厕所，只有一个坑位，一个人在使用的时候，其他人无法使用，只有第一个人使用完了，才能继续其他人使用。

//定义锁对象：
private final ReentrantLock lock=new ReentrantLock（）;
//定义需要保证线程安全的方法
public void m(){
lock.lock();
	try{
		保证安全执行的代码
	}//使用finally来释放锁
	finally{
	lock.unlock();
	}
}

还有一种算法是生产者与等待者算法，

生产者 生产一次 运送到工厂中，工厂只能存储1个产品，必须等待消费者把这个产品取走，生产者才能继续下一次生产，如果消费者不取走这个商品，生产者则无法生产。如果生产者一直不生产，那么消费者也没办法取商品。
这里我们需要使用到wait（）方法和notify（）方法，wait是让线程进行等待，

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 方法。比如在生产者-消费者里面的使用，每次都需要唤醒所有的消费者或是生产者，以判断程序是否可以继续往下执行。
7、在多线程中要测试某个条件的变化，使用if 还是while？
　　要注意，notify唤醒沉睡的线程后，线程会接着上次的执行继续往下执行。所以在进行条件判断时候，可以先把 wait 语句忽略不计来进行考虑，显然，要确保程序一定要执行，并且要保证程序直到满足一定的条件再执行，要使用while来执行，以确保条件满足和一定执行。

线程池的引入

系统启动一个新的线程的成本是十分的高的，使用线程池可以提高性能。线程池启动的时候创建了大量空闲的线程，程序将Runnable线程和Callable线程传给线程池，线程池会启动一个空闲的线程来执行他们的run或者call方法，执行完毕后线程不会死亡，等待下一个runnable对象的run方法或者call方法。

                //只有一个线程的线程池
                //ExecutorService pool=Executors.newSingleThreadExecutor();
                //线程池中最多可以放5个线程
                //ExecutorService pool=Executors.newFixedThreadPool(5); 
                //线程池中线程的个数不确定(可伸缩的线程池)
                ExecutorService pool=Executors.newCachedThreadPool();

这几个方法返回一个ExecutorService对象，这个对象代表一个线程池，这个线程池可以执行Runnable对象和Callable对象所代表的线程。只要交给了线程池的线程，那么这个线程池就会飞速的执行任务。ExecutorService便提供了如下的2种方法：
1） Future<?>submit（Runnable task）将一个Runnable对象提交给指定的线程池，Futher对象代表了Runnable的返回值，但是run方法没有返回值，执行完毕后返回null，我们可以调用isDone（），isCancelled（）获得Runnable对象的执行阶段。
2） Futuresubmit(Runnable task,T result);将一个Runnable提交给指定线程值，result是这个线程池的返回值

用完线程池需要调用shutdown（）方法

我们调用线程池的步骤如下：

1调用Executors类的静态工厂创建一个ExecutorService对象，这个对象代表了一个线程池。
2）调用Runnable实现类或者Callable的实现类的实例，来作为线程的执行任务。
3）调用ExecutorService对象的submit方法提交实例。
如果不想提交任务的时候需要调用shutdown方法结束线程池