Java多线程总结（一）

1.多线程的优势：同时运行多部分代码；劣势：效率降低。JVM在启动的时候，至少启动了两个线程，执行main函数的线程，垃圾回收线程。

2.垃圾回收机制，System.gc()方法告诉JVM调用finalize方法，但不一定立即执行。

3.创建线程的方式：第一种：继承Thread类。示例如下：

package heima.person.caizhanqi.basetest;

public class ThreadDemo extends Thread {
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
for (int i = 0; i < 10; i++) {
System.out.println(
Thread.currentThread().getName()
+"-----------"+this.getId());
}
}
public static void main(String[] args) {

new ThreadDemo().start();
for (int i = 0; i < 10; i++) {
+"-----------"
+Thread.currentThread().getId());
}
new ThreadDemo().start();
new ThreadDemo().start();
}
}

.

4.第二种：实现Runnable接口：优点：将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。示例如下：

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

public static void main(String[] args) {
ThreadDemo demo = new ThreadDemo();
new Thread(demo).start();
new Thread(demo).start();
new Thread(demo).start();
}

}

.

5.Thread类，Runnable接口模拟实现，如下：

public class ThreadDemo{
private Runnable r;
public ThreadDemo(){

}
public ThreadDemo(Runnable r){
this.r = r;
}

public void run(){
if(r!=null)
r.run();
}

public void start(){
run();
}

}

.

6.线程安全问题示例：

public class ThreadSecurity implements Runnable {
private int num;

public ThreadSecurity() {
// TODO Auto-generated constructor stub
}

public ThreadSecurity(int num) {
this.num = num;
}

@Override
public void run() {
while (num > 0) {
try {
System.out.println(
Thread.currentThread().getName()
+ "----sale..."+ num);
num--;
Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
}
}
}

public static void main(String[] args) {
ThreadSecurity t = new ThreadSecurity(10);
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}

.

7.线程安全问题产生的原因：1.多个线程在操作共享的数据；2.操作共享数据的线程代码有多条。由此可知，当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。

8.解决线程安全问题的方案：将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不能参与运算。必须要当前线程把这些代码都执行完毕，其他线程才能参与运算。

9.同步代码块：修饰词：synchronized.同步的好处：解决了线程的安全问题；弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中降低程序运行的效率。同步的前提：必须有多个线程使用同一个锁。

10.Synchroized修饰的函数锁是this，修饰的静态变量，锁是类的字节码文件，修饰的成员变量，锁可以是任意对象。

11.同步示例：

public class ThreadSynchronized implements Runnable {
private int num;
private boolean flag;
public ThreadSynchronized() {
flag = true;
num = 100;
}

@Override
public void run() {
if (flag) {
while (true) {
synchronized (this) {
if (num > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(
Thread.currentThread().getName()
+ "--true--" + num--);
}
}
}
} else {
while (true)
show();
}
}
public synchronized void show() {
if (num > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(
Thread.currentThread().getName() + "--flase--"
+ num--);
}
}
public static void main(String[] args) {
ThreadSynchronized ts = new ThreadSynchronized();
new Thread(ts).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
ts.flag = false;
new Thread(ts).start();
new Thread(ts).start();
}
}

.

12.多线程下的单例设计模式：1.饿汉式：不存在多个线程共同操作数据的情况，线程安全。

class SingleThread{
private static final SingleThread s = new SingleThread();
private SingleThread(){}
public SingleThread getSingleThread(){
return s;
}
}

2.懒汉式：存在线程安全问题。

Class SingleThread{
private static final SingleThread s = null;
Private SingleThread(){}
public SingleThread getSingleThread(){
if(s == null){
sysnchronized(SingleThread.class){
if(s == null){
S = new SingleThread();
}
}
}
return s;
}
}

.

13.死锁：想要获取的锁被别的线程所占有，互相不释放，导致程序不能继续执行下去。死锁示例：

public class DeadLock implements Runnable {
private int num = 1000;
private boolean flag;
private Object obj = new Object();
@Override
public void run() {
if (flag) {
while (true) {
synchronized (obj) {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(
Thread.currentThread().getName()
+ "--true--" + num--);
}
show();
}
}
} else {
while (true) {
show();
}
}
}
public synchronized void show() {
synchronized (obj) {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "--false--" + num--);
}
}
}
public static void main(String[] args) {
DeadLock dl = new DeadLock();
dl.flag = true;
new Thread(dl).start();
new Thread(dl).start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
dl.flag = false;
new Thread(dl).start();
}
}

.

14.多线程间的通信：多个线程在处理统一资源，但是任务不同，这时就需要多线程间的通信。等待/唤醒机制涉及的方法：1.wait()，让线程处于冻结状态，被wait()的线程会放在线程池中；2.notify()，唤醒线程池中的一个线程；3.notifyAll()，唤醒线程池中的所有线程。PS：wait释放执行权，释放锁。以上三个方法都定义在同步中，因为这些方法是用于操作线程状态的方法。

15.一对一的线程通信，线程被唤醒之后，会继续从之前wait的部分之后开始执行任务。一对一线程通信如下：

class Resource{
private int num = 0;
private boolean flag;
public void setResource(){
synchronized(this){
System.out.println("set...wait");
if(flag)
try {
Thread.sleep(100);
wait();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("set....notify");
num++;
flag = true;
System.out.println("in...."+num);
notify();
}
}
public void outResource(){
synchronized(this){
System.out.println("out...wait");
if (!flag)
try {
Thread.sleep(100);
wait();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("out...notify");
System.out.println("out...."+num);
flag = false;
notify();
}
}
}
class InDemo implements Runnable{
private Resource r;
public InDemo(Resource r) {
this.r = r;
}
@Override
public void run() {
while(true){
r.setResource();
}
}
}
class OutDemo implements Runnable{
private Resource r;
public OutDemo(Resource r) {
this.r = r;
}
@Override
public void run() {
while(true)
r.outResource();
}
}
public class ThreadDemo{
public static void main(String[] args) {
Resource r = new Resource();
InDemo in = new InDemo(r);
OutDemo out = new OutDemo(r);
new Thread(in).start();
new Thread(out).start();
}
}