java 多线程学习笔记

//自定义类，继承Thread类
public class MyThread extends Thread {

//重写类里对run()方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
System.out.println(getName() + ":" + i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

public static void main(String[] args) {
//创建一个线程对象
MyThread myThread = new MyThread();
MyThread myThread1 = new MyThread();
myThread.start();//启动线程
myThread1.start();
//匿名内部类方式实现
new Thread() {
@Override
public void run() {
//// TODO
}
}.start();
}

//自定义类，实现Runnable接口
public class MyRunnable implements Runnable {

@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + ":" + i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

public static void main(String[] args) {

MyRunnable my = new MyRunnable();
Thread t1 = new Thread(my);
Thread t2 = new Thread(my);
t1.start();//启动线程
t2.start();
//匿名内部类方式实现
new Thread(new Runnable() {
@Override
public void run() {
//// TODO
}
}).start();
}

//Callable：是带泛型的接口，这里指定的泛型其实是call()方法的返回值类型
public class MyCallable implements Callable<Integer> {
private int number;

public MyCallable(int number) {
this.number = number;
}

@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= number; i++) {
sum += i;
}
return sum;
}
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建线程池对象，创建两个线程对象。
ExecutorService pool = Executors.newFixedThreadPool(2);
//可以执行Callable对象或者Runnable对象代表的线程
Future<Integer> future = pool.submit(new MyCallable(100));//带返回结果
pool.submit(new MyRunnable());
//匿名内部类
pool.execute(new Runnable() {
@Override
public void run() {
//// TODO
}
});
Integer i = future.get();
System.out.println(i);

//结束
pool.shutdown();
}

public class MyRunnable implements Runnable {

private int money = 100;
@Override
public void run() {
doFunction();
}
private void doFunction() {
while (true)
//同步代码块
synchronized (MyRunnable.clss) {
if (money > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + money--);
}
}
}
}

public class MyRunnable implements Runnable {
private int money = 100;

@Override
public void run() {
doFunction();
}
//同步方法，这里是锁对象是this；如果方法是静态方法，锁对象是该类的字节码文件对象
private synchronized void doFunction() {
while (true)
if (money > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + money--);
}
}
}

public class MyRunnable implements Runnable {
private int money = 100;
//定义锁对象
private Lock lock = new ReentrantLock();

@Override
public void run() {
doFunction();
}
private void doFunction() {
while (true) {
try {
//加锁
lock.lock();
if (money > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + money--);
}
} finally {
//释放锁
lock.unlock();
}
}
}
}