Java多线程操作
Java中的线程
一个程序的运行须要启动一个应用进程，一个进程能够创建多个线程。帮助应用完毕多任务操作。实现并发运行。在Java中线程是被封装成Thread类。进行多线程操作时仅仅须要继承一个Thread类，实现自己的功能就可以。然后开启此线程，或者你也能够实现一个Runnable接口。然后将其传递给Thread对象。然后再启动它。
线程的创建于启动
继承Thread
创建一个类并继承Thread类，然后实现Thread类的run方法，在run方法内填上自己的代码。然后创建这个自己定义类，并调用其start方法来启动这个自己定义线程。
// 引入Thread
import java.lang.Thread;
/**
* 创建自己的Thread，实现run方法（放上自己要运行的内容）
*/
class MyThread extends Thread {
/**
* 覆盖超类Thread的run方法
*/
public void run() {
for(int i=0; i<10; i++) {
System.out.println("第" + i + "次循环");
}
}
}
class ThreadDemo1 {
public static void main(String[] args) {
// 创建一个自己定义线程。而且启动它
new MyThread().start();
}
}
/* 程序输出:
第0次循环
第1次循环
第2次循环
第3次循环
第4次循环
第5次循环
第6次循环
第7次循环
第8次循环
第9次循环
*/实现Runnable
一个实现过Runnable的对象都能够被一个Thread对象所运行。
import java.lang.Thread;
import java.lang.Runnable;
/**
* 创建一个类，实现Runnable接口。
*/
class MyRunnable implements Runnable {
/**
* 实现Runnable的run方法
*/
public void run() {
for(int i=0; i<5; i++) {
System.out.println("Runable：第" + i + "次循环");
}
}
}
class ThreadDemo2 {
public static void main(String[] args) {
// 创建一个线程。并创建一个实现过Runnable的对象
// 构造它，然后再启动这个线程
new Thread(new MyRunnable()).start();
}
}
/* 程序输出:
Runable：第0次循环
Runable：第1次循环
Runable：第2次循环
Runable：第3次循环
Runable：第4次循环
*/
synchronized的使用
既然是多线程。那么就会出现多线程的问题。如同一时候訪问同一资源。从而产生意料之外的结果。这是我们所不想看到的。在Java中能够非常easy的解决问题。使用synchronized对操作进行加锁。synchronized能够对对象加锁，也能够对函数进行加锁。以下对照一下未使用synchronized和使用synchronized的不同之处。
未使用synchronized的情况
import java.lang.Thread;
import java.lang.Runnable;
class MyRunnable implements Runnable {
private static int i=0;
public void run() {
for(; i<10; i++) {
try {
Thread.sleep(10);
} catch(Exception e) {
}
print(i);
}
}
private void print(int k) {
System.out.println(k);
}
}
class Demo {
public static void main(String[] args) {
MyRunnable r = new MyRunnable();
new Thread(r).start();
new Thread(r).start();
}
}能够看到结果不对，由于两个线程可能会同一时候进入线程，然后打印出两个同样的值。
0
0
2
3
4
5
6
7
8
9
10使用了synchronized后的情况
import java.lang.Thread;
import java.lang.Runnable;
class MyRunnable implements Runnable {
private static int i=0;
public void run() {
synchronized(this) {
for(; i<10; i++) {
try {
Thread.sleep(10);
} catch(Exception e) {
}
print(i);
}
}
}
private void print(int k) {
System.out.println(k);
}
}
class Demo {
public static void main(String[] args) {
MyRunnable r = new MyRunnable();
new Thread(r).start();
new Thread(r).start();
}
}当对for进行加锁处理后，便不会同一时候两个线程进入循环，这样打印的数字便不会出错。
0
1
2
3
4
5
6
7
8
9synchronized的加锁对象会有一个标志位（0/1）。默认的情况下是0，当线程运行到synchronized的加锁对象后假设对象的标志位为0。那么将其设置为1，否则等待。
这个标志位能够称之为“锁旗标”。这样以来便能够实现线程同步。
尽管synchronized攻克了多线程的不安全问题。可是也是有一定的弊端的。它会减少程序的运行效率，所以。synchronized不能够任意放置，应尽量将其放到必须使用的位置上。
如单例模式的一个样例：
public class Single {
private Single mInstance;
private Single(){
}
public static Single getInstance() {
if(mInstance == null) {
synchronized(Single.class) {
if(mInstance == null) {
mInstance = new Single();
}
}
}
return mInstance;
}
}这里的synchronized能够加在getInstance()前面，可是这样会大大减少运行效率，也能够去掉外层的if(mInstance == null)，可是这样也会添加不必要的推断，以为假设mInstance已经创建后便不须要锁了。若此以来，上面这样的写法是最好的。
最内层的if推断有必要说明一下，能够假设这样一种情况，两个线程都运行到第一个if的后面，那么。假设没有内层的if推断的话，mInstance会被创建两次，所以，内层的if是不可或缺的。
wait和notify的使用
wait和notify是Object对象中的两个方法。其作用是用于多线程中的控制，如想使用两个线程交替打印出Odd和Even时，详细代码例如以下：
import java.lang.Thread;
import java.lang.Runnable;
class Temp {
public static boolean flag = false;
}
class Odd implements Runnable{
public void run() {
while(true) {
if(Temp.flag) {
try {
wait();
} catch(Exception e) {}
}
System.out.println("Odd");
Temp.flag = !Temp.flag;
try {
notify();
} catch(Exception e) {}
}
}
}
class Even implements Runnable {
public void run() {
while(true) {
if(!Temp.flag) {
try {
wait();
} catch(Exception e) {}
}
System.out.println("Even");
Temp.flag = !Temp.flag;
try {
notify();
} catch(Exception e) {}
}
}
}
class Demo {
public static void main(String[] args) {
new Thread(new Odd()).start();
new Thread(new Even()).start();
}
}当然除了notify方法，还有notifyAll方法。用于唤醒全部线程。
Lock的使用
JDK1.5之后。也就是Java5.0之后。添加了很多新的内容，如用于线程控制的一些类，Lock的用法相当于synchronized，Lock中lock()和unlock()分别用于加锁和解锁，一般用法例如以下：
import java.lang.Runnable;
import java.lang.Thread;
import java.util.concurrent.locks.*;
class Locks implements Runnable {
private Lock lock = new ReentrantLock();
private int index = 0;
public void run() {
while(true) {
lock.lock();
System.out.print(index + " ");
try {
Thread.sleep(100);
} catch(Exception e) {}
index ++;
lock.unlock();
}
}
}
class Demo {
public static void main(String[] args) {
Locks locks = new Locks();
new Thread(locks).start();
new Thread(locks).start();
new Thread(locks).start();
}
}这样便能够顺序打印出0 1 2 3 4 ···。
通过Lock的对象，我们能够创建Condition对象，如
Condition condition = lock.newCondition();
然后能够使用condition.await();和condition.signal()来暂停和唤醒线程，当然还有condition.signalAll()来唤醒全部线程。
