Changeset 562


Ignore:
Timestamp:
09/05/12 05:06:30 (8 years ago)
Author:
BegemoT
Message:
 
Location:
Tests/JAVA/test/src/main/java/test/threads/queue
Files:
1 added
1 edited
1 copied

Legend:

Unmodified
Added
Removed
  • Tests/JAVA/test/src/main/java/test/threads/queue/stressed/TaskBenchmark.java

    r523 r562  
    11package test.threads.queue.stressed; 
    22 
    3 import java.io.*; 
     3import java.io.File; 
    44import java.lang.reflect.Constructor; 
    55import java.lang.reflect.InvocationTargetException; 
    66import java.text.ParseException; 
    7 import java.util.Arrays; 
    8 import java.util.Properties; 
     7import java.util.*; 
    98import java.util.concurrent.*; 
    109 
     
    2726 */ 
    2827public class TaskBenchmark { 
    29     private static final Log log = LogFactory.getLog( TaskBenchmark.class ); 
    30  
    31     public static final int QUEUE_CAPACITY = 32 << 10;//32K 
    32  
    33     public static final int EVENTS_IN_BATCH = 512; 
    34  
    35     private static final int TURNS = 5; 
    36  
    37     private static final long DEFAULT_BENCHMARK_DURATION_SECONDS = 30;//=30 sec 
    38     private static final long DEFAULT_WARMUP_DURATION_SECONDS = 30;//=30 sec 
    39  
    40     private static final String DEFAULT_CONFIG_FILE = "./config.properties"; 
    41  
    42  
    43     /** Arguments: (taskClass: "...") (usefulWorkFactoryID: "cpu"/"memory"/...) [taskSize: long] */ 
    44     public static void main( final String[] args ) throws Exception { 
    45         System.out.printf( "Java: %s, %s (%s)\n", 
    46                            System.getProperty( "java.version" ), 
    47                            System.getProperty( "java.vendor" ), 
    48                            System.getProperty( "java.home" ) 
    49         ); 
    50         System.out.printf( "Runtime: %s, VM: %s\n", 
    51                            System.getProperty( "java.runtime.version" ), 
    52                            System.getProperty( "java.vm.version" ) 
    53         ); 
    54         System.out.printf( "OS: %s %s (%s)\n\n", 
    55                            System.getProperty( "os.name" ), 
    56                            System.getProperty( "os.version" ), 
    57                            System.getProperty( "os.arch" ) 
    58         ); 
    59  
    60         final Options options = new Options(); 
    61         options.addOption( OptionBuilder.withLongOpt( "task" ) 
    62                                    .withDescription( "class of task to benchmark" ) 
    63                                    .hasArg() 
    64                                    .isRequired() 
    65                                    .withArgName( "TASK" ) 
    66                                    .create() 
    67         ); 
    68         options.addOption( OptionBuilder.withLongOpt( "payload" ) 
    69                                    .withDescription( "type of payload for benchmark" ) 
    70                                    .hasArg() 
    71                                    .isRequired() 
    72                                    .withArgName( "payload" ) 
    73                                    .create() 
    74         ); 
    75  
    76         options.addOption( OptionBuilder.withLongOpt( "config" ) 
    77                                    .withDescription( ".properties file containing configuration data (default is " + DEFAULT_CONFIG_FILE + ")" ) 
    78                                    .hasArg() 
    79                                    .withArgName( "CONFIG" ) 
    80                                    .create() 
    81         ); 
    82         options.addOption( OptionBuilder.withArgName( "property=value" ) 
    83                                    .hasArgs( 2 ) 
    84                                    .withValueSeparator() 
    85                                    .withDescription( "use value for given property" ) 
    86                                    .create( "D" ) 
    87         ); 
    88  
    89         final CommandLineParser parser = new GnuParser(); 
    90         try { 
    91             final CommandLine cmd = parser.parse( options, args ); 
    92  
    93  
    94             final String taskClass = cmd.getOptionValue( "task" ); 
    95             final String usefulWorkFactoryID = cmd.getOptionValue( "payload" ); 
     28        private static final Log log = LogFactory.getLog( TaskBenchmark.class ); 
     29 
     30        public static final int QUEUE_CAPACITY = 32 << 10;//32K 
     31 
     32        public static final int EVENTS_IN_BATCH = 512; 
     33 
     34        private static final int TURNS = 5; 
     35 
     36        private static final long DEFAULT_BENCHMARK_DURATION_SECONDS = 30;//=30 sec 
     37        private static final long DEFAULT_WARMUP_DURATION_SECONDS = 30;//=30 sec 
     38 
     39        private static final String DEFAULT_CONFIG_FILE = "./config.properties"; 
     40 
     41 
     42        /** Arguments: (taskClass: "...") (usefulWorkFactoryID: "cpu"/"memory"/...) [taskSize: long] */ 
     43        public static void main( final String[] args ) throws Exception { 
     44                System.out.printf( "Java: %s, %s (%s)\n", 
     45                                   System.getProperty( "java.version" ), 
     46                                   System.getProperty( "java.vendor" ), 
     47                                   System.getProperty( "java.home" ) 
     48                ); 
     49                System.out.printf( "Runtime: %s, VM: %s\n", 
     50                                   System.getProperty( "java.runtime.version" ), 
     51                                   System.getProperty( "java.vm.version" ) 
     52                ); 
     53                System.out.printf( "OS: %s %s (%s)\n\n", 
     54                                   System.getProperty( "os.name" ), 
     55                                   System.getProperty( "os.version" ), 
     56                                   System.getProperty( "os.arch" ) 
     57                ); 
     58 
     59                final Options options = new Options(); 
     60                options.addOption( OptionBuilder.withLongOpt( "task" ) 
     61                                                   .withDescription( "class of task to benchmark" ) 
     62                                                   .hasArg() 
     63                                                   .isRequired() 
     64                                                   .withArgName( "TASK" ) 
     65                                                   .create() 
     66                ); 
     67                options.addOption( OptionBuilder.withLongOpt( "payload" ) 
     68                                                   .withDescription( "type of payload for benchmark" ) 
     69                                                   .hasArg() 
     70                                                   .isRequired() 
     71                                                   .withArgName( "payload" ) 
     72                                                   .create() 
     73                ); 
     74 
     75                options.addOption( OptionBuilder.withLongOpt( "config" ) 
     76                                                   .withDescription( ".properties file containing configuration data (default is " + DEFAULT_CONFIG_FILE + ")" ) 
     77                                                   .hasArg() 
     78                                                   .withArgName( "CONFIG" ) 
     79                                                   .create() 
     80                ); 
     81                options.addOption( OptionBuilder.withArgName( "property=value" ) 
     82                                                   .hasArgs( 2 ) 
     83                                                   .withValueSeparator() 
     84                                                   .withDescription( "use value for given property" ) 
     85                                                   .create( "D" ) 
     86                ); 
     87 
     88                final CommandLineParser parser = new GnuParser(); 
     89                try { 
     90                        final CommandLine cmd = parser.parse( options, args ); 
     91 
     92 
     93                        final String taskClass = cmd.getOptionValue( "task" ); 
     94                        final String usefulWorkFactoryID = cmd.getOptionValue( "payload" ); 
    9695 
    9796//            final int opsPerPacket = Integer.parseInt( cmd.getOptionValue( "opsPerPacket" ) ); 
    9897 
    99             final String configFile; 
    100             if ( cmd.hasOption( "config" ) ) { 
    101                 configFile = cmd.getOptionValue( "config" ); 
    102             } else { 
    103                 configFile = DEFAULT_CONFIG_FILE; 
    104             } 
    105             final Config config = Config.load( new File( configFile ) ); 
    106  
    107             final Properties properties = cmd.getOptionProperties( "D" ); 
    108             config.append( properties ); 
    109  
    110             config.print( System.out ); 
    111  
    112             final ThreadFactory threadFactory = createThreadFactory( config ); 
    113  
    114             //create task 
    115             final ITask task = createTaskInstance( taskClass, config ); 
    116  
    117             final int workersCount = task.workersRequired(); 
    118             //create pool 
    119             final ExecutorService pool = Executors.newFixedThreadPool( workersCount, threadFactory ); 
    120  
    121             //create stress factory 
    122             final IUsefulWorkFactory usefulWorkFactory = createUsefulWorkFactory( 
    123                     usefulWorkFactoryID, 
    124                     config 
    125             ); 
     98                        final String configFile; 
     99                        if( cmd.hasOption( "config" ) ) { 
     100                                configFile = cmd.getOptionValue( "config" ); 
     101                        } else { 
     102                                configFile = DEFAULT_CONFIG_FILE; 
     103                        } 
     104                        final Config config = Config.load( new File( configFile ) ); 
     105 
     106                        final Properties properties = cmd.getOptionProperties( "D" ); 
     107                        config.append( properties ); 
     108 
     109                        config.print( System.out ); 
     110 
     111                        final ThreadFactory threadFactory = createThreadFactory( config ); 
     112 
     113                        //create task 
     114                        final ITask task = createTaskInstance( taskClass, config ); 
     115 
     116                        final int workersCount = task.workersRequired(); 
     117                        //create pool 
     118                        final ExecutorService pool = Executors.newFixedThreadPool( workersCount, threadFactory ); 
     119 
     120                        //create stress factory 
     121                        final IUsefulWorkFactory usefulWorkFactory = createUsefulWorkFactory( 
     122                                        usefulWorkFactoryID, 
     123                                        config 
     124                        ); 
    126125 
    127126//            final int opsPerNode = opsPerPacket / workersCount; 
    128             final IUsefulWorkEmulator[] emulators = usefulWorkFactory.createEmulators( workersCount ); 
    129  
    130             task.initialize( pool, emulators, usefulWorkFactory ); 
    131  
    132  
    133             final String taskName = task.toString(); 
    134             final String payloadID = usefulWorkFactory.toString(); 
    135  
    136             final long benchmarkDurationMs = TimeUnit.SECONDS.toMillis( 
    137                     config.getAsLong( 
    138                             "general.benchmark-duration", 
    139                             DEFAULT_BENCHMARK_DURATION_SECONDS 
    140                     ) 
    141             ); 
    142             final long warmUpDurationMs = TimeUnit.SECONDS.toMillis( 
    143                     config.getAsLong( 
    144                             "general.warm-up-duration", 
    145                             DEFAULT_WARMUP_DURATION_SECONDS 
    146                     ) 
    147             ); 
    148             final int turns = config.getAsInt( "general.turns", TURNS ); 
    149             final int measurements = config.getAsInt( "general.measurements", 1 ); 
    150             System.out.printf( 
    151                     "%s: %d s for warm up, %d for benchmark, payload: %s, %d turns of %d measurements\n\n", 
    152                     task, 
    153                     warmUpDurationMs / 1000, 
    154                     benchmarkDurationMs / 1000, 
    155                     usefulWorkFactory, 
    156                     turns, 
    157                     measurements 
    158             ); 
    159             log.info( "\n\n\n" ); 
    160             try { 
    161                 {//warm up JIT 
    162                     final BenchmarkResult[] results = task.execute( warmUpDurationMs, warmUpDurationMs, 1 ); 
    163                     for ( final BenchmarkResult result : results ) { 
    164                         System.out.println( "Warm up " + result.print( taskName, payloadID ) ); 
    165                     } 
    166                     System.out.println(); 
    167                 } 
    168                 for ( int i = 0; i < turns; i++ ) { 
    169                     final BenchmarkResult[] results = task.execute( warmUpDurationMs, benchmarkDurationMs, measurements ); 
    170                     for ( final BenchmarkResult result : results ) { 
    171                         System.out.println( result.print( taskName, payloadID ) ); 
    172                         log.info( result.printTabular( taskName, payloadID ) ); 
    173                     } 
    174                     System.out.println(); 
    175                     log.info( "" ); 
    176  
    177                     System.gc(); 
    178                     System.gc(); 
    179                     Thread.sleep( 500 );//give GC time to finish async tasks 
    180                 } 
    181             } catch ( Exception e ) { 
    182                 e.printStackTrace( System.err ); 
    183             } finally { 
    184                 task.terminate(); 
    185  
    186                 pool.shutdown(); 
    187                 pool.awaitTermination( 1, TimeUnit.SECONDS ); 
    188                 pool.shutdownNow(); 
    189             } 
    190             System.exit( 0 ); 
    191         } catch ( org.apache.commons.cli.ParseException e ) { 
    192             log.error( "Error parsing command line arguments", e ); 
    193         } 
    194         final HelpFormatter formatter = new HelpFormatter(); 
    195         formatter.printHelp( "vanga", options ); 
    196     } 
    197  
    198     private static ITask createTaskInstance( final String taskClass, 
    199                                              final Config config ) throws InstantiationException, IllegalAccessException, ClassNotFoundException, InvocationTargetException { 
    200         final Class<? extends ITask> clazz = ( Class<? extends ITask> ) Class.forName( taskClass ); 
    201         try { 
    202             final Constructor<? extends ITask> ctor = clazz.getConstructor( Config.class ); 
    203             return ctor.newInstance( config ); 
    204         } catch ( NoSuchMethodException e ) { 
    205             return clazz.newInstance(); 
    206         } 
    207     } 
    208  
    209     private static IUsefulWorkFactory<?> createUsefulWorkFactory( final String usefulWorkFactoryID, 
    210                                                                   final Config config ) throws InstantiationException, IllegalAccessException, ClassNotFoundException { 
    211         if ( "cpu".equals( usefulWorkFactoryID ) ) { 
    212             return new CPUWasterFactory( config ); 
    213         } else if ( "memory".equals( usefulWorkFactoryID ) ) { 
    214             return new MemoryWasterFactory( config ); 
    215         } else if ( "cpu-memory".equals( usefulWorkFactoryID ) ) { 
    216             return new CPUMemoryWasterFactory( config ); 
    217         } else if ( "none".equals( usefulWorkFactoryID ) ) { 
    218             return new DummyWasterFactory( config ); 
    219         } 
    220         throw new UnsupportedOperationException( "Method is not implemented for " + usefulWorkFactoryID ); 
    221     } 
    222  
    223     private static ThreadFactory createThreadFactory( final Config config ) throws ParseException { 
    224         if ( config.hasProperty( "general.affinity" ) ) { 
    225             final String affinityStr = config.getAsString( "general.affinity", null ); 
    226             try { 
    227                 final Core[] cores = ThreadAffinity.parseCores( affinityStr, null ); 
    228                 if ( cores != null && cores.length > 1 ) { 
    229                     System.out.printf( "Cores to attach: %s \n", Arrays.toString( cores ) ); 
    230                     //set thread priority 
    231                     final Core mainThreadCore = cores[0]; 
    232  
    233                     BenchmarkThreadFactory.setupCurrentThreadAsBenchmarking( mainThreadCore ); 
    234  
    235                     final BenchmarkThreadFactory factory = new BenchmarkThreadFactory( "benchmarking-thread", cores ); 
    236  
    237                     //just to move over first core, which is already used for main thread 
    238                     factory.newThread( null ); 
    239  
    240                     return factory; 
    241                 } 
    242             } catch ( ParseException e ) { 
    243                 System.err.printf( 
    244                         "Affinity string [%s] parsing error: %s\n", 
    245                         affinityStr, 
    246                         e.getMessage() 
    247                 ); 
    248             } 
    249         } 
    250         return new BenchmarkThreadFactory( "benchmarking-thread" ); 
    251  
    252         //set process priority 
    253         /*try { 
    254             ThreadAffinity.nice( -20 ); 
    255         } catch ( Exception e ) { 
    256             System.out.printf( "Can't set nice(-20) -> %s\n", e.getMessage() ); 
    257         }*/ 
    258  
    259     } 
     127                        final IUsefulWorkEmulator[] emulators = usefulWorkFactory.createEmulators( workersCount ); 
     128 
     129                        task.initialize( pool, emulators, usefulWorkFactory ); 
     130 
     131 
     132                        final String taskName = task.toString(); 
     133                        final String payloadID = usefulWorkFactory.toString(); 
     134 
     135                        final long benchmarkDurationMs = TimeUnit.SECONDS.toMillis( 
     136                                        config.getAsLong( 
     137                                                        "general.benchmark-duration", 
     138                                                        DEFAULT_BENCHMARK_DURATION_SECONDS 
     139                                        ) 
     140                        ); 
     141                        final long warmUpDurationMs = TimeUnit.SECONDS.toMillis( 
     142                                        config.getAsLong( 
     143                                                        "general.warm-up-duration", 
     144                                                        DEFAULT_WARMUP_DURATION_SECONDS 
     145                                        ) 
     146                        ); 
     147                        final int turns = config.getAsInt( "general.turns", TURNS ); 
     148                        final int measurements = config.getAsInt( "general.measurements", 1 ); 
     149                        System.out.printf( 
     150                                        "%s: %d s for warm up, %d for benchmark, payload: %s, %d turns of %d measurements\n\n", 
     151                                        task, 
     152                                        warmUpDurationMs / 1000, 
     153                                        benchmarkDurationMs / 1000, 
     154                                        usefulWorkFactory, 
     155                                        turns, 
     156                                        measurements 
     157                        ); 
     158                        log.info( "\n\n\n" ); 
     159                        try { 
     160                                {//warm up JIT 
     161                                        final BenchmarkResult[] results = task.execute( warmUpDurationMs, warmUpDurationMs, 1 ); 
     162                                        for( final BenchmarkResult result : results ) { 
     163                                                System.out.println( "Warm up " + result.print( taskName, payloadID ) ); 
     164                                        } 
     165                                        System.out.println(); 
     166                                } 
     167                                for( int i = 0; i < turns; i++ ) { 
     168                                        final BenchmarkResult[] results = task.execute( warmUpDurationMs, benchmarkDurationMs, measurements ); 
     169                                        for( final BenchmarkResult result : results ) { 
     170                                                System.out.println( result.print( taskName, payloadID ) ); 
     171                                                log.info( result.printTabular( taskName, payloadID ) ); 
     172                                        } 
     173                                        System.out.println(); 
     174                                        log.info( "" ); 
     175 
     176                                        System.gc(); 
     177                                        System.gc(); 
     178                                        Thread.sleep( 500 );//give GC time to finish async tasks 
     179                                } 
     180                        } catch( Exception e ) { 
     181                                e.printStackTrace( System.err ); 
     182                        } finally { 
     183                                task.terminate(); 
     184 
     185                                pool.shutdown(); 
     186                                pool.awaitTermination( 1, TimeUnit.SECONDS ); 
     187                                pool.shutdownNow(); 
     188                        } 
     189                        System.exit( 0 ); 
     190                } catch( org.apache.commons.cli.ParseException e ) { 
     191                        log.error( "Error parsing command line arguments", e ); 
     192                } 
     193                final HelpFormatter formatter = new HelpFormatter(); 
     194                formatter.printHelp( "benchmark", options ); 
     195        } 
     196 
     197        private static ITask createTaskInstance( final String taskClass, 
     198                                                 final Config config ) throws InstantiationException, IllegalAccessException, ClassNotFoundException, InvocationTargetException { 
     199                final Class<? extends ITask> clazz = ( Class<? extends ITask> ) Class.forName( taskClass ); 
     200                try { 
     201                        final Constructor<? extends ITask> ctor = clazz.getConstructor( Config.class ); 
     202                        return ctor.newInstance( config ); 
     203                } catch( NoSuchMethodException e ) { 
     204                        return clazz.newInstance(); 
     205                } 
     206        } 
     207 
     208        private static IUsefulWorkFactory<?> createUsefulWorkFactory( final String usefulWorkFactoryID, 
     209                                                                      final Config config ) throws InstantiationException, IllegalAccessException, ClassNotFoundException { 
     210                if( "cpu".equals( usefulWorkFactoryID ) ) { 
     211                        return new CPUWasterFactory( config ); 
     212                } else if( "memory".equals( usefulWorkFactoryID ) ) { 
     213                        return new MemoryWasterFactory( config ); 
     214                } else if( "cpu-memory".equals( usefulWorkFactoryID ) ) { 
     215                        return new CPUMemoryWasterFactory( config ); 
     216                } else if( "none".equals( usefulWorkFactoryID ) ) { 
     217                        return new DummyWasterFactory( config ); 
     218                } 
     219                throw new UnsupportedOperationException( "Method is not implemented for " + usefulWorkFactoryID ); 
     220        } 
     221 
     222        private static ThreadFactory createThreadFactory( final Config config ) throws ParseException { 
     223                if( config.hasProperty( "general.affinity" ) ) { 
     224                        final String affinityStr = config.getAsString( "general.affinity", null ); 
     225                        try { 
     226                                final Core[] cores = ThreadAffinity.parseCores( affinityStr, new int[0] ); 
     227                                if( cores != null && cores.length > 1 ) { 
     228                                        System.out.printf( "Cores to attach: %s \n", Arrays.toString( cores ) ); 
     229                                        //set thread priority 
     230                                        final Core mainThreadCore = cores[0]; 
     231 
     232                                        BenchmarkThreadFactory.setupCurrentThreadAsBenchmarking( mainThreadCore ); 
     233 
     234                                        final BenchmarkThreadFactory factory = new BenchmarkThreadFactory( "benchmarking-thread", cores ); 
     235 
     236                                        //just to move over first core, which is already used for main thread 
     237                                        factory.newThread( null ); 
     238 
     239                                        return factory; 
     240                                } 
     241                        } catch( ParseException e ) { 
     242                                System.err.printf( 
     243                                                "Affinity string [%s] parsing error: %s\n", 
     244                                                affinityStr, 
     245                                                e.getMessage() 
     246                                ); 
     247                        } 
     248                } 
     249                return new BenchmarkThreadFactory( "benchmarking-thread" ); 
     250 
     251                //set process priority 
     252                /*try { 
     253                                        ThreadAffinity.nice( -20 ); 
     254                                } catch ( Exception e ) { 
     255                                        System.out.printf( "Can't set nice(-20) -> %s\n", e.getMessage() ); 
     256                                }*/ 
     257 
     258        } 
    260259} 
  • Tests/JAVA/test/src/main/java/test/threads/queue/unstressed/impl/CAQWrapperQueue.java

    r561 r562  
    11package test.threads.queue.unstressed.impl; 
    2  
    3 import java.util.concurrent.ConcurrentLinkedQueue; 
    42 
    53import test.threads.queue.unstressed.IBoundedQueueFactory; 
     
    75 
    86/** 
    9  * Самый базовый вариант, адаптер {@link java.util.concurrent.ConcurrentLinkedQueue} к интерфейсу IQueue. 
     7 * Самый базовый вариант, адаптер {@link ConcurrentArrayQueue} к интерфейсу IQueue. 
    108 * 
    119 * @author cheremin 
    1210 * @since 22.09.11,  13:09 
    1311 */ 
    14 public class CLQWrapperQueue<T> implements IQueue<T> { 
     12public class CAQWrapperQueue<T> implements IQueue<T> { 
    1513 
    16     private final ConcurrentLinkedQueue<T> queue; 
    17     private final int size; 
     14        private final ConcurrentArrayQueue<T> queue; 
     15        private final int size; 
    1816 
    19     public CLQWrapperQueue( final int size ) { 
    20         this.queue = new ConcurrentLinkedQueue<T>(); 
    21         this.size = size; 
    22     } 
     17        public CAQWrapperQueue( final int size ) { 
     18                final int initialSegmentCapacity = 16; 
     19                final int initialSegmentCount = size / initialSegmentCapacity; 
     20                this.queue = new ConcurrentArrayQueue<T>( 
     21                                initialSegmentCount, 
     22                                initialSegmentCapacity 
     23                ); 
     24                this.size = size; 
     25        } 
    2326 
    24     @Override 
    25     public void enqueue( final T item ) throws InterruptedException { 
    26         while ( queue.size() >= size ) { 
    27         } 
    28         queue.add( item ); 
    29     } 
     27        @Override 
     28        public void enqueue( final T item ) throws InterruptedException { 
     29                while( queue.size() >= size ) { 
     30                } 
     31                queue.add( item ); 
     32        } 
    3033 
    31     @Override 
    32     public T dequeue() throws InterruptedException { 
    33         while ( true ) { 
    34             final T event = queue.poll(); 
    35             if ( event != null ) { 
    36                 return event; 
    37             } 
    38         } 
    39     } 
     34        @Override 
     35        public T dequeue() throws InterruptedException { 
     36                while( true ) { 
     37                        final T event = queue.poll(); 
     38                        if( event != null ) { 
     39                                return event; 
     40                        } 
     41                } 
     42        } 
    4043 
    41     @Override 
    42     public int size() { 
    43         return queue.size(); 
    44     } 
     44        @Override 
     45        public int size() { 
     46                return queue.size(); 
     47        } 
    4548 
    46     @SuppressWarnings( "unchecked" ) 
    47     public static <T> IBoundedQueueFactory<T, CLQWrapperQueue<T>> factory() { 
    48         return FACTORY; 
    49     } 
     49        @SuppressWarnings( "unchecked" ) 
     50        public static <T> IBoundedQueueFactory<T, CAQWrapperQueue<T>> factory() { 
     51                return FACTORY; 
     52        } 
    5053 
    51     public static final IBoundedQueueFactory FACTORY = new IBoundedQueueFactory<Object, CLQWrapperQueue<Object>>() { 
    52         @Override 
    53         public CLQWrapperQueue<Object> create( final int size ) { 
    54             return new CLQWrapperQueue<Object>( size ); 
    55         } 
     54        public static final IBoundedQueueFactory FACTORY = new IBoundedQueueFactory<Object, CAQWrapperQueue<Object>>() { 
     55                @Override 
     56                public CAQWrapperQueue<Object> create( final int size ) { 
     57                        return new CAQWrapperQueue<Object>( size ); 
     58                } 
    5659 
    57         @Override 
    58         public String toString() { 
    59             return "CLQWrapperFactory"; 
    60         } 
    61     }; 
     60                @Override 
     61                public String toString() { 
     62                        return "CAQWrapperFactory"; 
     63                } 
     64        }; 
    6265} 
Note: See TracChangeset for help on using the changeset viewer.