一、多线程实现方式
1.继承Thread类，重写run方法
public class ThreadDemo extends Thread{
@Override
public void run(){
//编写自己的线程代码
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args){
ThreadDemo threadDemo = new ThreadDemo();
threadDemo.setName("我是自定义的线程1");
threadDemo.start();
System.out.println(Thread.currentThread().toString());
}
}
优点 ：代码简单 。 缺点 ：该类无法集成别的类。
2.实现Runnable接口，重写run方法
通过实现Runnable接口，实现run方法，接口的实现类的实例作为Thread的target作为参数传入带参的Thread构造函数，通过调用start()方法启动线程
public class MyThreadRunable implements Runnable{
public static void main(String[] arg){
MyThreadRunable runable = new MyThreadRunable();
Thread myThread = new Thread(runable);
myThread.start();
System.out.println("step2");
}
@Override
public void run() {
System.out.println("step1");
try {
sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
优点 ：继承其他类。 同一实现该接口的实例可以共享资源。
缺点 ：代码复杂
3.通过Callable和FutureTask创建线程
1）创建Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，且该 call() 方法有返回值 。
2）创建Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象， 该 FutrueTask 对象封装了该 Callable 对象的 call() 方法的返回值。
3）使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
public class ThreadDemo {
public static void main(String[] args) {
Callable<Object> oneCallable = new Tickets<Object>();
FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
Thread t = new Thread(oneTask);
System.out.println(Thread.currentThread().getName());
t.start();
}
}
class Tickets<Object> implements Callable<Object>{
//重写call方法
@Override
public Object call() throws Exception {
System.out.println(Thread.currentThread().getName());
return null;
}
}
优点 ：可以获得返回值
start() : 作用是启动一个新线程，新线程会执行相应的run()方法。start()不能被重复调用,真正的实现了多线程并发运行。
run() : 只是类的一个普通方法而已，直接调用run方法的话，程序中依然只有主线程这一个线程，其程序执行路径还是要顺序执行，要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。
二、线程中的状态
java中，每个线程都需经历新生、就绪、运行、阻塞和死亡五种状态，线程从新生到死亡的状态变化称为生命周期。
用new运算符和Thread类或其子类建立一个线程对象后，该线程就处于新生状态。
新生—>就绪:通过调用start()方法。
就绪—>运行:处于就绪状态的线程一旦得到CPU，就进入运行状态并自动调用run()方法。
运行—>阻塞:处于运行状态的线程,执行sleep()方法，或等待I/O设备资源，让出CPU并暂时中止运行，进入阻塞状态。
阻塞—>就绪:睡眠时间已到,或等待的I/O设备空闲下来，线程便进入就绪状态，重新到就绪队列中等待CPU。当再次获得CPU时，便从原来中止位置开始继续运行。
运行—>死亡:(1)线程任务完成；(2)线程被强制性的中止,如通过执行stop()或destroy()方法来终止线程。
三、如何优雅的终止一个线程
线程终止有两种情况：线程的任务执行完成；线程在执行任务过程中发生异常。
1、使用stop()方法，已被弃用。原因是：stop()是立即终止，比较暴力，会带来数据不一致性，所以被废弃。
2、使用退出标志：实现一个Runnable接口，在其中定义volatile标志位，在run()方法中使用标志位控制程序运行，当一个变量被 volatile 修饰时，任何线程对它的写操作都会立即刷新到主内存中，并且会强制让缓存了该变量的线程中的数据清空，必须从主内存重新读取最新数据。
3、使用interrupt()中断的方式，使用interrupt()方法中断正在运行中的线程只会修改中断状态位，可以通过isInterrupted()判断。如果使用interrupt()方法中断阻塞中的线程，那么就会抛出InterruptedException异常，可以通过catch捕获异常，然后进行处理后终止线程。有些情况，我们不能判断线程的状态，所以使用interrupt()方法时一定要慎重考虑。
四、线程中sleep()和wait()有何区别
sleep（）：使当前线程暂停执行指定的一段时间，但监视状态依然保持，过了指定的时间会自行恢复运行状态。
wait（）：使当前线程暂停执行，同时释放对象监视器的所有权，直到另一个和它有相同对象监视器的线程调用notify（）或者notifyAll（）唤醒它，再恢复运行状态。
（1）sleep（）不会释放资源，wait（）会释放资源；
（2）sleep（）是Thread类里的函数，wait（）是Object类里的函数；
（3）sleep（）可以在任何地方调用，wait（）只能在同步方法或者同步代码块中调用（否则会抛IllegalMonitorStateException异常）；
五、Runnable接口和Callable接口的区别
Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。
六、多线程同步
（1）synchronized关键字：synchronized有两种用法：synchronized方法和synchronized块
public synchronized void mutithreadAccess();
synchronized(syncObject){代码块｝
当一个线程进入一个对象的synchronized()方法后，其他线程是否能够进入此对象的其他方法？
答案：其他线程可进入此对象的非synchronized修饰的方法。如果其他方法有synchronized修饰，都用的是同一对象锁，就不能访问。
如果其他方法是静态方法，且被synchronized修饰，是否可以访问？
答案：可以的，因为static修饰的方法，它用的锁是当前类的字节码，而非静态方法使用的是this，因此可以调用。
（2）Thread类的join()方法
join()方法是Thread中的一个public方法，它有几个重载版本：
1. join()
2. join(long millis) //参数为毫秒
3. join(long millis,int nanoseconds) //第一参数为毫秒，第二个参数为纳秒
（3）wait()方法和notify()方法：当使用synchronized来修饰某个共享资源时，如果线程A1执行synchronized代码，另外一个线程A2也要同时执行同一对象的同一 synchronized代码时，线程A2将要等到线程A1执行完后，才能继续执行。这种情况下可以使用wait()方法和notify()方法。
在synchronized代码被执行期间，线程可以调用对象的wait方法，释放对象锁，进入等待状态，并且可以调用notify()方法或notify()方法通知正在等待的其他线 程。notify()方法仅唤醒一个线程（等待队列中的第一个线程）并允许它去获得锁，notifyAll()方法唤醒所有等待这个对象的线程并允许它们去获得锁。
（4）Lock
ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力
ReenreantLock类的常用方法有：
1. ReentrantLock() : 创建一个ReentrantLock实例
2. lock() : 获得锁
3.unlock() : 释放锁
七、一些编程题
1、编写一个有两个线程的程序，第一个线程用来计算2～100000之间的素数的个数，第二个线程用来计算100000～200000之间的素数的个数，最后输出结果。
package classtest;
public class ThreadSushu extends Thread{
int i,j,x=0;
ThreadSushu (int m,int n){
this.i=m;
this.j=n;
}
public static void main(String[] args) {
ThreadSushu thread1=new ThreadSushu(2,100000);
ThreadSushu thread2=new ThreadSushu(100000,200000);
thread1.start();
thread2.start();
}
public void run(){
int p,q;
p=0;q=0;
for(int m=i;m<=j;m++) {
for(int h=1;h<=m;h++) {
q=m%h;
if(q==0)p=p+1;
}
if(p==2) {
x=x+1;
}
p=0;
}
System.out.println("输出"+i+"到"+j+"之间的质数个数："+x);
}
}
2、设计2个线程，定义一个变量j，初始值为0。其中第1个线程每个循环对j增加1，循环1000次。另外1个线程对j每次减少1，循环1000次。保证线程安全，最终两个线程执行完j的值仍然是0
package classtest;
public class Thread2 extends Thread{
static int j=0;
static Object lock=new Object();
int flag=0;
Thread2(int flag){
this.flag=flag;
}
public static void main(String[] args) throws InterruptedException {
Thread2 thread1=new Thread2(1);
Thread2 thread2=new Thread2(2);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(j);
}
public void run(){
for(int i=0;i<100000;i++) {
synchronized(lock){
if (flag == 1) {
j=j+2;
} else {
j=j-1;
}
}
}
}
}
3、假如新建T1、T2、T3三个线程，同时启动，如何保证它们按顺序执行？也就是先执行T1，执行完后，再执行T2，执行完后，再执行 T3
package classtest;
public class JoinTest {
public static void main(String[] args) {
Thread t1=new Thread(new Work(null));
Thread t2=new Thread(new Work(t1));
Thread t3=new Thread(new Work(t2));
t1.start();
t2.start();
t3.start();
}
static class Work implements Runnable {
private Thread t;
public Work(Thread t) {
this.t = t;
}
public void run() {
if (t != null) {
try {
t.join();
System.out.println("thread start:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
System.out.println("thread start:" + Thread.currentThread().getName());
}
}
}
}
4、写两个线程，一个线程打印1~52，另一个线程打印A~Z，打印顺序是12A34B...5152Z；
package classtest;
public class TwoThread {
public static void main(String args[]){
MyObject1 my = new MyObject1();
new Thread(new Runnable(){
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 0; i < 26; i++){
my.printNum();
}
}
}).start();
new Thread(new Runnable(){
@Override
public void run() {
// TODO Auto-generated method stub
for(int i = 0; i < 26; i++){
my.printA();
}
}
}).start();
}
}
class MyObject1{
private static boolean flag = true ;
public int count = 1;
public synchronized void printNum(){
while(flag == false){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.print((2*count-1));
System.out.print(2*count);
flag = false;
this.notify();
}
public synchronized void printA(){
while(flag == true){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.print((char)(count+'A'-1));
count++;
flag = true;
this.notify();
}
}
5、编写10个线程，第一个线程从1加到10，第二个线程从11加20…第十个线程从91加到100，最后再把10个线程结果相加。
package classtest;
public class TenThread {
public static class SumThread extends Thread{
int forct = 0; int sum = 0;
SumThread(int forct){
this.forct = forct;
}
@Override
public void run() {
for(int i = 1; i <= 10; i++){
sum += i + forct * 10;
}
System.out.println(getName() + " " + sum);
}
}
public static void main(String[] args) {
int result = 0;
for(int i = 0; i < 10; i++){
SumThread sumThread = new SumThread(i);
sumThread.start();
try {
sumThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = result + sumThread.sum;
}
System.out.println("result " + result);
}
}
