******** 传统的多线程 *******
创建线程的方式：
在传递给Thread对象的Runnable对象的run方法中编写代码
Thread子类覆盖run方法编写代码
总结：由源码可以看到这两种方式都是在调用Thread的run方法。如果Thread的run方法没有被覆盖，并且为Thread对象设置一个Runnable对象，run方法会调用Runnable对象的ruan方法
如果Thread子类覆盖了run方法，并且传递了一个Runnable对象，结果是调用Runnable对象的run方法(牵涉到：匿名内部类对象的构造方法如何调用父类的非默认构造方法)
线程的三种调用方法：
//方法一
Thread thread=new Thread(){
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("测试线程"+i+Thread.currentThread().getName());
System.out.println(this.getName());//这个也可以，但不建议用
}
}
};
thread.start();
//方法二
new Thread(){
public void run() {
System.out.println("线程第三种创建方法");
}
}.start();
//另一种调用线程的方法,经常用这个，更体现面向对象的思想
Thread thread3=new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("测试线程"+i+Thread.currentThread().getName());
//System.out.println(this.getName());//这个已经不能使用了，因为this指向的是Runnable子类
}
}
});
thread3.start();
********** 定时器 ***********
工具类 quartz
//一个简单的定时器
new Timer().schedule(new TimerTask(){
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("定时器内容");
}}, 10000,1000);//第一个时间是隔了多长时间执行，第二个时间是第一次执行之后每隔多长时间执行一次
用于产生附加信息：
while (true) {
System.out.println(new Date().getSeconds());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
子母定时器：
class MyTimerTask extends TimerTask{
@Override
public void run() {
// TODO Auto-generated method stub
count=(count+1)%2;
System.out.println("子母测试");
new Timer().schedule(new MyTimerTask(), 2000+2000*count);
}
}
new Timer().schedule(new MyTimerTask(), 2000);
****** 传统线程的互斥技术 *****
package TraditionalThread;
public class TraditionalThreadSynchronized {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
//final OutPut outPut=new OutPut();//报错，静态方法中不能new内部类的实例化对象
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
outPut.output("peerless");
}
}).start();*/
new TraditionalThreadSynchronized().init();
}
private void init() {
final OutPut outPut=new OutPut();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
outPut.output1("peerlesspeerlesspeerless");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
outPut.output2("64396732034832038732047083437258340");
}
}
}).start();
}
static class OutPut{
public void output1(String str) {
synchronized (this) {
for (int i = 0; i < str.length(); i++) {
System.out.print(str.charAt(i));
}
System.out.println();
}
}
public synchronized void output2(String str) {
for (int i = 0; i < str.length(); i++) {
System.out.print(str.charAt(i));
}
System.out.println();
}
}
public static void output3(String str) {
synchronized (OutPut.class) {
for (int i = 0; i < str.length(); i++) {
System.out.print(str.charAt(i));
}
System.out.println();
}
}
}
****** 传统多线程通信 *********
wait与notify实现线程之间的通信
经验：要用到共同数据(包括同步锁)的若干方法应该归在同一个类身上，这种设计正好体现了高聚类和程序的健壮性
package TraditionalThread;
public class TraditionalThreadCommunication {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
final Business business=new Business();
new Thread(
new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 50; i++) {
business.main(i);
}
}
}
).start();
for (int i = 0; i < 50; i++) {
business.sub(i);
}
}
}
//单独写一个类用来处理输出
class Business{
private boolean flag=true;
public synchronized void main(int i){
if (!flag) {
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for (int j = 0; j < 10; j++) {
System.out.println("主线程调用第"+i+"轮,第"+j+"次");
}
flag=false;
this.notify();
}
public synchronized void sub(int i) {
if (flag) {
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for (int j = 0; j < 10; j++) {
System.out.println("子线程调用第"+i+"轮,第"+j+"次");
}
flag=true;
this.notify();
}
}
******** 线程范围内共享数据 *********
方法： 用map集合类来记住每个线程对应的只能自己使用的数据
Map shareData=new HashMap();//创建map集合类来存放线程和其对应资源
****** ThreadLocal实现线程范围的共享变量 **********
ThreadLocal mThreadLocal=new ThreadLocal();
对象的set和get方法
***** 多个线程访问共享对象和数据的方式 *******
如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据
如果每个线程的代码不同，这时候就用不同的Runnable对象，有如下两种方法实现这些Runnable对象之间的数据共享
1 将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象，每个线程对共享说句的操作方法也分配到那个对象身上去完成，这样很容易实现对该数据进行各个操作的互斥和通信
2 将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行各个操作的互斥和通信，作为内部类的各个RUnnable对象调用外部类的这些方法
上面两种结合，将共享数据封装到一个对象中，每个线程对恭喜那个数据的操作也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或者方法中的局部变量，每个线程的RUnnable对象作为外部类中的成员内部类或者局部内部类
总之：要同步互斥的几段代码，最好是分别放在几个独立的方法中，这些方法在放到同一个类中，这样比较容易实现他们之间的同步互斥和通信
前两种的源码：
package TraditionalThread;
public class MultiThreadShareData {
private static ShareData1 data1 = new ShareData1();
public static void main(String[] args) {
ShareData1 data2 = new ShareData1();
new Thread(new MyRunnable1(data2)).start();
new Thread(new MyRunnable2(data2)).start();
final ShareData1 data1 = new ShareData1();
new Thread(new Runnable(){
@Override
public void run() {
data1.decrement();
}
}).start();
new Thread(new Runnable(){
@Override
public void run() {
data1.increment();
}
}).start();
}
}
class MyRunnable1 implements Runnable{
private ShareData1 data1;
public MyRunnable1(ShareData1 data1){
this.data1 = data1;
}
public void run() {
data1.decrement();
}
}
class MyRunnable2 implements Runnable{
private ShareData1 data1;
public MyRunnable2(ShareData1 data1){
this.data1 = data1;
}
public void run() {
data1.increment();
}
}
class ShareData1 /*implements Runnable*/{
/*private int count = 100;
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
count--;
}
}*/
private int j = 0;
public synchronized void increment(){
j++;
}
public synchronized void decrement(){
j--;
}
}
第三种： 思路： 共享变量放到主函数外，定义内部类(增加和减少两个)实现Runnable接口 创建线程之前，创建两个内部类的对象，然后再用for循环创建多个线程(其中增加减少操作也可以封装成互斥函数，便于同步)
