https://www.cnblogs.com/lijingran/p/8722301.html
1.线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。
线程不安全就是不提供数据访问保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据
ArrayList和Vector有什么区别?HashMap和HashTable有什么区别?StringBuilder和StringBuffer有什么区别?这些都是Java面试中常见的基础问题。面对这样的问题,回答是:ArrayList是非线程安全的,Vector是线程安全的;HashMap是非线程安全的,HashTable是线程安全的;StringBuilder是非线程安全的,StringBuffer是线程安全的
public class Main
{
public static void main(String[] args)
{
// 进行10次测试
for(int i = 0; i < 10; i++)
{
test();
}
}
public static void test()
{
// 用来测试的List
List<Object> list = new ArrayList<Object>();
// 线程数量(1000)
int threadCount = 1000;
// 用来让主线程等待threadCount个子线程执行完毕
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
// 启动threadCount个子线程
for(int i = 0; i < threadCount; i++)
{
Thread thread = new Thread(new MyThread(list, countDownLatch));
thread.start();
}
try
{
// 主线程等待所有子线程执行完成,再向下执行
countDownLatch.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
// List的size
System.out.println(list.size());
}
}
class MyThread implements Runnable
{
private List<Object> list;
private CountDownLatch countDownLatch;
public MyThread(List<Object> list, CountDownLatch countDownLatch)
{
this.list = list;
this.countDownLatch = countDownLatch;
}
public void run()
{
// 每个线程向List中添加100个元素
for(int i = 0; i < 100; i++)
{
list.add(new Object());
}
// 完成一个子线程
countDownLatch.countDown();
}
}
99815
99430
99824
99827
99600
99427
99641
99840
99615
99859
- countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。
- 是通过一个计数器来实现的,计数器的初始值是线程的数量。每当一个线程执行完毕后,计数器的值就-1,当计数器的值为0时,表示所有线程都执行完毕,然后在闭锁上等待的线程就可以恢复工作了。
作者:指尖架构141319
链接:https://www.jianshu.com/p/e233bb37d2e6
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
再用线程安全的Vector来进行测试,上面代码改变一处,test()方法中
List<Object> list = new ArrayList<Object>();
改为
List<Object> list = new Vector<Object>();
再运行程序。
输出结果:
100000
100000
100000
100000
100000
100000
100000
100000
100000
100000
实际上vector add方法的实现也就是加了synchronized
线程安全的实现
线程安全是通过线程同步控制来实现的,也就是synchronized关键字。
在这里,我用代码分别实现了一个非线程安全的计数器和线程安全的计数器Counter,并对他们分别进行了多线程测试。
非线程安全的计数器:
public class Main
{
public static void main(String[] args)
{
// 进行10次测试
for(int i = 0; i < 10; i++)
{
test();
}
}
public static void test()
{
// 计数器
Counter counter = new Counter();
// 线程数量(1000)
int threadCount = 1000;
// 用来让主线程等待threadCount个子线程执行完毕
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
// 启动threadCount个子线程
for(int i = 0; i < threadCount; i++)
{
Thread thread = new Thread(new MyThread(counter, countDownLatch));
thread.start();
}
try
{
// 主线程等待所有子线程执行完成,再向下执行
countDownLatch.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
// 计数器的值
System.out.println(counter.getCount());
}
}
class MyThread implements Runnable
{
private Counter counter;
private CountDownLatch countDownLatch;
public MyThread(Counter counter, CountDownLatch countDownLatch)
{
this.counter = counter;
this.countDownLatch = countDownLatch;
}
public void run()
{
// 每个线程向Counter中进行10000次累加
for(int i = 0; i < 10000; i++)
{
counter.addCount();
}
// 完成一个子线程
countDownLatch.countDown();
}
}
class Counter
{
private int count = 0;
public int getCount()
{
return count;
}
public void addCount()
{
count++;
}
}
稍加修改,把Counter改成线程安全的计数器:
class Counter
{
private int count = 0;
public int getCount()
{
return count;
}
public synchronized void addCount()
{
count++;
}
}
2.为什么实现runnable接口 而不继承Thread类
多个线程处理同一个资源,runnable接口 new一个对象出来后,Thread构造函数接受这个对象,启动多个线程,操作一个对象资源。
传统的继承Thread 每个Thread都是操作Thread的资源,不能做到资源共享。
一、通过继承Thread类实现多线程
class MyThread extends Thread{
String name = null;
int ticket = 0;
public MyThread(String name){
this.name = name;
}
public synchronized void run(){
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+this.name+" ticket:"+ticket++);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
MyThread mThread1 = new MyThread("线程一");
MyThread mThread2 = new MyThread("线程二");
MyThread mThread3 = new MyThread("线程三");
mThread1.start();
mThread2.start();
mThread3.start();
}
Thread-1线程二 ticket:0
Thread-0线程一 ticket:0
Thread-2线程三 ticket:0
Thread-1线程二 ticket:1
Thread-0线程一 ticket:1
Thread-2线程三 ticket:1
Thread-1线程二 ticket:2
Thread-2线程三 ticket:2
Thread-0线程一 ticket:2
Thread-1线程二 ticket:3
Thread-2线程三 ticket:3
Thread-0线程一 ticket:3
Thread-1线程二 ticket:4
Thread-2线程三 ticket:4
Thread-0线程一 ticket:4
二、通过继承Runnable接口实现多线程
class RunThread implements Runnable{
int Counter = 0;
@Override
public synchronized void run() {
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"count:"+Counter++);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
RunThread rThread = new RunThread();
Thread t1 = new Thread(rThread,"线程一");
Thread t2 = new Thread(rThread,"线程二");
Thread t3 = new Thread(rThread,"线程三");
t1.start();
t2.start();
t3.start();
}
线程一count:0
线程一count:1
线程一count:2
线程一count:3
线程一count:4
线程二count:5
线程二count:6
线程二count:7
线程二count:8
线程二count:9
线程三count:10
线程三count:11
线程三count:12
线程三count:13
线程三count:14
https://www.cnblogs.com/centor/p/5738550.html