UPDATE SEQUENCE_TABLE
   SET SEQ_DT = TRUNC(SYSDATE),
       SEQ_VAL = CASE SEQ_DT
                   WHEN TRUNC(SYSDATE) THEN SEQ_VAL + 1
                   ELSE 1
                 END
  RETURNING SEQ_VAL
    INTO V_SEQ_VAL;

declare
l_val number;
begin
    execute immediate
    'select my_table_seq.nextval from dual' INTO l_val;

    execute immediate
    'alter sequence my_table_seq increment by -' || l_val || 
                                                          ' minvalue 0';

    execute immediate
    'select my_table_seq.nextval from dual' INTO l_val;

    execute immediate
    'alter sequence my_table_seq increment by 1 minvalue 0';
end;
/

Here is the procedure written to handle parallel processing sequence.

create or replace PROCEDURE prc_get_nxt_seq(po_seq OUT NUMBER)
IS
  PRAGMA autonomous_transaction;
  l_lock_name           CONSTANT VARCHAR2(20) := 'EMP_SEQ';
  l_sleep_sec           CONSTANT NUMBER       := 1;
  l_lock_handle         VARCHAR2(100);
  l_lock_id             NUMBER;
  l_lock_release        NUMBER;
  l_seq                 NUMBER;
  l_record_count        NUMBER;
  
BEGIN
  --dbms_output.put_line( sysdate||': StartSerialProcess()' );
  --// create a lock handle
  dbms_lock.allocate_unique( lockname        => l_lock_name, 
                             lockHandle      => l_lock_handle, 
                             expiration_secs => 0 
                           );
  --// attempt to lock in order to start process, else
  --// loop and wait for the lock to become available
  --// for us to use.
  LOOP
    --// attempt a lock
    l_lock_id := dbms_lock.request( lockhandle => l_lock_handle, 
                                    timeout    => 1 
                                  );
  EXIT
  WHEN l_lock_id != 1; --// lock was successful
    --// locking failed - another process is busy, we
    --// need to wait 
    --// retrying the lock)
    dbms_lock.sleep( l_sleep_sec );
  END LOOP;
  --// we have made the lock and can now continue to process...
  
  SELECT COUNT(1) 
  INTO l_record_count 
  FROM  system_data 
  WHERE NAME ='EMP_SEQ' ;

  IF l_record_count < 1 
  THEN  
  
    INSERT INTO SYSTEM_DATA
       (
        name,
        value,
        mod_date
        )
      SELECT 'EMP_SEQ', 0 ,TRUNC(SYSDATE) FROM dual;  
      
  END IF;     
              
  UPDATE system_data
  SET mod_date = TRUNC(SYSDATE),
      mod_user = USER ,
      value    = CASE  TRUNC(mod_date)
                   WHEN TRUNC(SYSDATE) THEN value + 1
                   ELSE 1
                 END
  WHERE name = 'EMP_SEQ' 
  RETURNING value
    INTO l_seq;
  commit;  
  po_seq := l_seq;
  --dbms_lock.sleep( 5 ); --// pretend processsing for 5 secs for testing purpose;
  --// when processing is completed, we need to release the
  --// the lock handle
  l_lock_release := dbms_lock.release( l_lock_handle );
  
EXCEPTION WHEN OTHERS 
THEN
l_lock_release := dbms_lock.release( l_lock_handle );
END prc_get_nxt_seq; 

create table file_locks (current_date date,the_seq number);


CREATE OR REPLACE FUNCTION Bld_file_name (P_file_prefix IN VARCHAR2)
    RETURN VARCHAR2
IS
    PRAGMA AUTONOMOUS_TRANSACTION;
    V_the_seq        NUMBER;
    V_current_date   DATE;
BEGIN
    SELECT CURRENT_DATE, The_seq
      INTO V_current_date, V_the_seq
      FROM File_locks
    FOR UPDATE;

    -- check to see if we need to restart the sequence
    IF V_current_date < TRUNC (SYSDATE)
    THEN
        UPDATE File_locks
           SET CURRENT_DATE = TRUNC (SYSDATE), The_seq = 0;

        V_the_seq := 0;
    END IF;

    -- increment the sequence
    UPDATE File_locks
       SET The_seq = The_seq + 1;

    COMMIT;
    RETURN    P_file_prefix
           || '_'
           || TO_CHAR (SYSDATE, 'YYYYMMDD')
           || '_'
           || TO_CHAR (V_the_seq + 1, 'fm999999000');
END Bld_file_name;

CREATE OR REPLACE
  FUNCTION Bld_file_name(
                         P_FILE_PREFIX IN VARCHAR2,
                         P_CURRENT_DATE IN DATE
                        )
    RETURN VARCHAR2
    IS
        V_THE_SEQ NUMBER:
        PRAGMA AUTONOMOUS_TRANSACTION;
    BEGIN
        UPDATE File_locks
           SET CURRENT_DATE = TRUNC(P_CURRENT_DATE),
               THE_SEQ = CASE CURRENT_DATE
                           WHEN TRUNC(P_CURRENT_DATE) THEN THE_SEQ + 1
                           ELSE 1
                         END
           RETURNING THE_SEQ
             INTO V_THE_SEQ;
    COMMIT;
    RETURN    P_FILE_PREFIX ||
              TO_CHAR(P_CURRENT_DATE,'_YYYYMMDD_') ||
              TO_CHAR(V_THE_SEQ,'FM000');
END Bld_file_name;
/

CREATE OR REPLACE
  FUNCTION Bld_file_name(
                         P_FILE_PREFIX IN VARCHAR2,
                         P_CURRENT_DATE IN DATE
                        )
    RETURN VARCHAR2
    IS
        V_THE_SEQ NUMBER:
        PRAGMA AUTONOMOUS_TRANSACTION;
    BEGIN
        UPDATE File_locks
           SET CURRENT_DATE = TRUNC(P_CURRENT_DATE),
               THE_SEQ = CASE CURRENT_DATE
                           WHEN TRUNC(CURRENT_DATE) THEN THE_SEQ + 1
                           ELSE 1
                         END
           RETURNING THE_SEQ
             INTO V_THE_SEQ;
    COMMIT;
    RETURN    P_FILE_PREFIX ||
              TO_CHAR(P_CURRENT_DATE,'_YYYYMMDD_') ||
              TO_CHAR(V_THE_SEQ,'FM999999000');
END Bld_file_name;

    RETURN    P_FILE_PREFIX ||
              TO_CHAR(P_CURRENT_DATE,'_YYYYMMDD_') ||
              V_THE_SEQ;

UPDATE File_locks
           SET CURRENT_DATE = TRUNC(P_CURRENT_DATE),
               THE_SEQ = CASE "CURRENT_DATE"
                           WHEN TRUNC(P_CURRENT_DATE) THEN THE_SEQ + 1
                           ELSE 1
                         END
           RETURNING THE_SEQ
             INTO V_THE_SEQ;

select * from V$RESERVED_WORDS where keyword = 'CURRENT_DATE'
/
KEYWORD     	LENGTH	RESERVED	RES_TYPE	RES_ATTR	RES_SEMI	DUPLICATE
------------	------	--------	--------	--------	--------	---------
CURRENT_DATE	12    	N       	N       	N       	N       	N