Java并发-多线程

1.多线程

1. 线程状态
   每个线程可以看做不同的任务，cpu需要分配每个线程不同的使用时间，cpu需要不同的线程之间来回切换，造成线程可能存在的不同状态。

2. 新建线程

• 继承Thread，重写run方法，new Thread来进行新建线程。
• 实现Runnable，重写run方法，new Thread（new Runnanle（））来进行构造

public class Thread1 extends Thread{
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println(this.getName()+"---"+i);
		}
	}
}
public class Runnable1 implements Runnable{

	@Override
	public void run() {
		for(int i =0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+"---"+i);
		}
	}

}
public class test {
	public static void main(String[] args) {
		new Thread1().start();
		new Thread(new Runnable1()).start();
	}
}

如果多运行几次，总会有线程一输入的数据穿插在线程二之中，说明cpu是在不同线程之间切换。两种线程的新建方法，实现接口更加好一点，更加灵活，因为只能单继承，多实现。

3. 线程的方法

• wait() 让线程进入等待并放弃该线程所持有的锁
• notify() 随机唤醒一个线程，notifyAll() 唤醒所用等待的线程
• sleep() 让线程进入等待但不放弃该线程所持有的锁
• join() 指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程
• currentThread() 获取当前线程的Thread对象
• interrupt 中断线程
• interrupted 判断当前线程是否被中断
  这里的方法都很简单，试试就知道了，额外讲一下join方法。

public class test {
	public static void main(String[] args) throws InterruptedException {
		Thread t =  new Thread1();
		t.start();
		new Thread(new Runnable1()).start();
	}
}

• 加上join()方法之后

public class test {
	public static void main(String[] args) throws InterruptedException {
		Thread t =  new Thread1();
		t.start();
		t.join();
		new Thread(new Runnable1()).start();
	}
}

两个线程从交叉执行变成了串行方式，看一下join的源码，发现它是由synchronized 方法修饰的，每个类都具有一个对象锁，synchronized 修饰的方法执行时会获取这个对象锁，其他线程不能方法，需要等该线程执行完/释放锁才可以。

    public final synchronized void join(long millis)
    throws InterruptedException {
    	//当前的毫秒数据
        long base = System.currentTimeMillis();
        long now = 0;
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

4. 线程优先级
   每个线程都具有优先级，默认为1-10，调用setPriority( int newPriority)方法来提高或者降低任何线程的优先级，具有较高的优先级会具有更多的cpu使用权。

2.同步

多个线程访问相同对象的时候，存取数据的时候回造成误伤.

• 误伤例子–购票问题

public class ticket {
	int count = 10;
	public  void saleTicket()  {
		if(this.count>0) {
			//模拟多线程一起购买最后一张票，并购买成功
			if(this.count==1) {
				Thread.currentThread();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			count--;
			System.out.println(Thread.currentThread().getName() + "---" + "购票成功！！！" + "余票还有" + this.count);
		}	
	}
}
public class Thread1 extends Thread {
	private ticket ticket;
	public Thread1(ticket t) {
		this.ticket = t;
	}
	public void run() {
		while (true) {
			ticket.saleTicket();
			if (ticket.getCount() == 0)
				break;
		}
	}
}
public class test {
	public static void main(String[] args) throws InterruptedException {
		ticket a = new ticket();
		Thread t =  new Thread1(a);
		Thread s = new Thread1(a);
		t.start();
		s.start();
	}
}

于是，可能出现这种问题！！！当票们还有一张的时候，两个线程都通过判断（通过线程睡眠模拟了一下情况），并买了票，票的余额为-1。So,虽然出现的几率很小，但还是要避免。

• 常用方法如下：

• synchronized修饰的方法，同步方法

public synchronized  void saleTicket（）{
	//买票
}

• synchronized修饰的代码块，同步代码块

synchronized (对象) {
	//需要同步的内容
}

• 使用volatile关键字,给需要的同步的变量添加该关键字，不过对于我这个例子没有作用
• 使用重入锁实现线程同步，也就是new一个锁拿来用

	//Lock是个接口，需要用到子类ReentrantLock来新建锁。
	private Lock lock = new ReentrantLock();
	//方法一共两个，lock()，unlock()，理解为上锁，解锁，也可以用trylock来判断该对象锁是否已经被持有。
	lock.lock();
	//需要同步的代码
	lock.unlock()；